コード例 #1
0
ファイル: sqlite.go プロジェクト: kien8995/judger
func (this *Sqlite) createTable() {
	o := orm.NewOrm()

	table1 := `CREATE TABLE [session] (
[id] INTEGER  PRIMARY KEY NOT NULL,
[session] VARCHAR(128)  UNIQUE NOT NULL,
[create_time] TIME DEFAULT CURRENT_TIMESTAMP NOT NULL
)`

	table2 := `CREATE TABLE [task] (
[id] INTEGER  PRIMARY KEY AUTOINCREMENT NOT NULL,
[task_id] VARCHAR(128)  UNIQUE NOT NULL,
[language] VARCHAR(64) DEFAULT '''C''' NOT NULL,
[type] VARCHAR(16) DEFAULT '''io''' NOT NULL,
[io_data] TEXT  NULL,
[code] TEXT  NULL,
[time] TIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
[build_log] TEXT  NULL,
[build_result] VARCHAR(128)  NULL,
[run_result] VARCHAR(128)  NULL,
[debug_info] TEXT  NULL
)`

	_, err := o.Raw(table1).Exec()
	if err != nil {
		log.Blueln(err)
	}

	_, err = o.Raw(table2).Exec()
	if err != nil {
		log.Blueln(err)
	}

}
コード例 #2
0
ファイル: ccpp.go プロジェクト: kien8995/judger
func (this *Compile) NewCompile() {
	this.buildOverTime = false
	this.system = runtime.GOOS
	this.postfix_c = "c"
	this.postfix_cpp = "cpp"
	this.currentPath, _ = os.Getwd()

	this.buildPath = filepath.Join(this.currentPath, core.C.Get(runtime.GOOS, "buildpath"))
	this.compiler_c = filepath.Join(this.currentPath, core.C.Get(runtime.GOOS, "compiler_c"))

	log.Blueln("[current path]", this.currentPath)
	log.Blueln("[build path]", this.buildPath)
	log.Blueln("[compiler path]", this.compiler_c)
}
コード例 #3
0
ファイル: problem_bank.go プロジェクト: jango2015/ojsite
// 通过problem
// id bank中的ID
func (this *ProblemBank) AcceptProblem(id int) error {
	o := orm.NewOrm()
	var prob ProblemBank
	var err error

	prob.Id = id

	// read problem in problem bank
	err = o.Read(&prob, "Id")

	if err != nil {
		return err
	}

	// create problem
	var pro Problem
	op := orm.NewOrm()

	pro.Title = prob.Title
	pro.Pbid = prob.Id
	pro.Type = prob.Type
	pro.Description = prob.Description
	pro.PreCode = prob.PreCode
	pro.IoData = prob.IoData
	pro.Tags = prob.Tags
	pro.Level = "public"

	log.Blueln("[problem copy from bank to list]")
	log.Blueln(pro)

	// insert into problem
	pid, err := op.Insert(&pro)
	if err != nil {
		return err
	} else if pid == 0 {
		return errors.New("insert error, id is 0.")
	}

	// update problem bank
	prob.Status = "ok"
	_, err = o.Update(&prob)
	if err != nil {
		return err
	} else {
		return nil
	}

}
コード例 #4
0
ファイル: cache.go プロジェクト: dw250100785/blog-1
func SetCache(key string, value interface{}, timeout int64) error {
	data, err := Encode(value)
	if err != nil {
		return err
	}
	if cc == nil {
		return errors.New("cc is nil")
	}

	defer func() {
		if r := recover(); r != nil {
			log.Redf("set cache error caught: %v\n", r)
			cc = nil
		}
	}()

	err = cc.Put(key, data, timeout)
	if err != nil {
		log.Warnln("Cache失败,key:", key)
		return err
	} else {
		log.Blueln("Cache成功,key:", key)
		return nil
	}
}
コード例 #5
0
ファイル: ccpp.go プロジェクト: kien8995/judger
func checkTimer(cmd *exec.Cmd, comp *Compile, id int) {
	for {
		// if building process hava exit normally, exit timer
		if BuildProcessHaveExit {
			log.Blueln("Building Process Exit Normally.")
			return
		}

		stn := time.Now()
		now := stn.UnixNano()
		// over 10s
		if now-BuildStartTime > 10*1000000000 {
			comp.buildOverTime = true
			log.Warnln("Building Out of Time, Terminated!")
			cmd.Process.Kill()

			systemTag := com.SubString(runtime.GOOS, 0, 5)
			if systemTag == "linux" {
				// ps -ef|grep cc1|grep 5.c|awk '{print $2}'|xargs kill -9
				cleanScript := fmt.Sprintf("ps -ef|grep cc1|grep %d.c|awk '{print $2}'|xargs kill -9", id)
				cleanCmd := exec.Command("sh",
					"-c",
					cleanScript,
				)
				err := cleanCmd.Run()
				if err != nil {
					log.Warnln("clean orphan failed")
				}
			}
			return
		}
	}
}
コード例 #6
0
ファイル: client.go プロジェクト: kien8995/judger
// start the session
func (this *JClient) Start(ip string, port int, password string) error {
	// not login, first time
	this.login = false

	// default # to get the real sep
	this.mark = "#"
	addr := fmt.Sprintf("%s:%d", ip, port)
	conn, err := net.Dial("tcp", addr)
	if err != nil {
		if conn != nil {
			conn.Close()
		}

		log.Warnln("connect judge server failed in port:", port)

		return err
	} else {
		this.conn = conn
		this.connected = true
		content, err := this.read()
		if err != nil {
			return err
		}

		// get seperater mark
		reg := regexp.MustCompile(`/[\d\D]+$`)
		if arr := reg.FindAllString(content, -1); len(arr) > 0 {
			this.mark = com.SubString(arr[0], 1, 1)
		}

		log.Blueln(content)
	}

	// login
	loginRequest := map[string]interface{}{
		"action":   "login",
		"password": password,
	}

	response, err := this.Request(loginRequest)
	if err != nil {
		return err
	}

	result, ok := response["result"].(bool)
	if !result || !ok {
		return errors.New("login failed.")
	}

	sid, ok := response["sid"].(string)
	if ok {
		this.sid = sid
	} else {
		this.sid = ""
	}

	this.login = true

	return err
}
コード例 #7
0
ファイル: oauth.go プロジェクト: jango2015/ojsite
func (this *OAuthController) Get() {
	code := this.GetString("code")
	clientId := beego.AppConfig.String("github_client_id")
	clientSecret := beego.AppConfig.String("github_client_secret")

	oauthGithub := &oauth.GithubOAuth{}
	token, json, err := oauthGithub.GetData(clientId, clientSecret, code)

	if err != nil {
		this.Ctx.WriteString("Response Error! ")
		return
	} else {
		log.Blueln(json)
	}

	user := models.User{}
	oa := models.OAuth{}

	if this.Data["userIs"] == "guest" {
		result, usr := oa.GithubLogin(token, "github")
		if result {
			log.Blueln("github login success.")
			this.SetSession("username", usr.Username)
			this.SetSession("level", usr.Level)
			this.Redirect("/", 302)
		} else {
			log.Warnln("you have not register or bindding you github account.")
			this.Redirect("/register", 302)
		}

	} else {
		// have login, binding github oauth
		data := json.(map[string]interface{})
		avatar := data["avatar_url"].(string)
		username := data["login"].(string)
		gojAvatar, _ := user.GetAvatar(0, this.Data["username"].(string), "", "")

		this.Data["title"] = "github绑定确认"
		this.Data["github_avatar"] = avatar
		this.Data["goj_avatar"] = gojAvatar
		this.Data["token"] = token
		this.Data["github_username"] = username

		this.TplNames = "user/github_binding_confirm.tpl"
	}

}
コード例 #8
0
ファイル: http.go プロジェクト: kien8995/judger
func HttpStart() {

	http.HandleFunc("/", HandleJsonRpc)

	err := http.ListenAndServe(":1005", nil)
	if err != nil {
		log.Warnln("ListenAndServe: ", err)
	} else {
		log.Blueln("Http Server Started!")
	}
}
コード例 #9
0
ファイル: article.go プロジェクト: dw250100785/blog-1
func (this *ArticleController) Get() {
	id, err := this.GetInt("id")
	uri := this.Ctx.Input.Param(":uri")

	log.Blueln("[uri]", uri)

	var art Article
	if nil == err && id != 0 {
		art, err = GetArticle(int(id))
	} else if "" != uri {
		art, err = GetArticleByUri(uri)
	} else {
		this.Abort("404")
		this.TplNames = "error/404.tpl"
		return
	}

	if 0 == art.Id {
		this.Abort("404")
		this.TplNames = "error/404.tpl"
		return
	}

	maps, err := CountByMonth()
	if nil == err {
		this.Data["count_by_month"] = maps
	}

	hottest, err := HottestArticleList()
	if nil == err {
		this.Data["hottest"] = hottest
	}

	if nil != err {
		this.Data["json"] = map[string]interface{}{"result": false, "msg": "invalid request", "refer": "/"}
		this.ServeJson()
	}

	if 0 != art.Id {
		UpdateCount(art.Id)
	}

	this.Data["id"] = art.Id
	this.Data["title"] = art.Title
	this.Data["uri"] = art.Uri
	this.Data["content"] = art.Content
	this.Data["author"] = art.Author
	this.Data["time"] = art.Time
	this.Data["count"] = art.Count
	this.Data["keywords"] = art.Keywords
	this.Data["description"] = art.Title
	this.Data["duoshuo"] = beego.AppConfig.String("duoshuo_short_name")
	this.TplNames = "article.tpl"
}
コード例 #10
0
ファイル: project.go プロジェクト: BaiTang/blog
func (this *ProjectListController) Get() {
	page, err := this.GetInt64("page")
	if nil != err || page < 0 {
		page = 0
	}

	s := this.Ctx.Input.Param(":page")
	pageParm, err := strconv.Atoi(s)
	if nil != err || pageParm < 0 {
		pageParm = 0
	} else {
		page = int64(pageParm)
	}

	if 0 == page {
		page = 1
	}

	// maps, err := CountByMonth()

	// if nil == err {
	// this.Data["count_by_month"] = maps
	// }

	maps, nextPageFlag, totalPages, err := ListProjects(int(page), 10)

	if totalPages < int(page) {
		page = int64(totalPages)
	}

	log.Blueln("[page]", page)

	var prevPageFlag bool
	if 1 >= page {
		prevPageFlag = false
	} else {
		prevPageFlag = true
	}

	if nil == err {
		this.Data["title"] = "项目"
		this.Data["keywords"] = "项目"
		this.Data["description"] = "独孤影的项目"
		this.Data["prev_page"] = fmt.Sprintf("/project/%d", page-1)
		this.Data["prev_page_flag"] = prevPageFlag
		this.Data["next_page"] = fmt.Sprintf("/project/%d", page+1)
		this.Data["next_page_flag"] = nextPageFlag
		this.Data["projects_in_page"] = maps
	}

	this.TplNames = "project.tpl"

}
コード例 #11
0
ファイル: list.go プロジェクト: jango2015/ojsite
func (this *ProblemListController) Get() {
	pro := &models.Problem{}
	problems, hasNext, _, _ := pro.ListProblem(1, 10, "public")

	top10, _ := pro.GetTop10()
	log.Blueln("[top 10]", top10)

	tag := &models.Tags{}
	tagList, _ := tag.TagList()
	log.Blueln("[tags]", tagList)

	this.Data["title"] = this.Lang("title_problem_list")

	this.Data["problems"] = problems
	this.Data["title"] = this.Lang("title_problems")
	this.Data["has_next"] = hasNext

	this.Data["top10"] = top10
	this.Data["tag_list"] = tagList

	this.TplNames = "problem/list.tpl"
}
コード例 #12
0
ファイル: http.go プロジェクト: kien8995/judger
func HandleJsonRpc(w http.ResponseWriter, r *http.Request) {
	// get request content
	p := make([]byte, r.ContentLength)
	r.Body.Read(p)

	content := string(p)

	log.Blueln(content)

	json, err := com.JsonDecode(content)

	if err != nil {
		log.Warnln("not json-rpc format")
		return
	}

	data := json.(map[string]interface{})

	// get system password
	password := C.Get("", "password")

	// parse received password
	passwordRecv, ok := data["password"].(string)
	if !ok {
		result, _ := com.JsonEncode(map[string]interface{}{
			"result": false, //bool, login result
			"msg":    "invalid password, password must be string.",
		})
		io.WriteString(w, result)
		return
	}

	// compare password
	if password != passwordRecv {
		result, _ := com.JsonEncode(map[string]interface{}{
			"result": false, //bool, login failed
		})
		io.WriteString(w, result)
		return
	}

	// trigger controller
	ctrl, exists := RouterMap[data["action"].(string)]
	if !exists {
		log.Warnln("not exist")
		return
	}
	ctrl.Http(data, w, r)
}
コード例 #13
0
ファイル: utils.go プロジェクト: jango2015/ojsite
func (this *MarkdownController) Post() {
	content := this.GetString("content")

	log.Blueln(content)
	rst := utils.Markdown2HTML(content)

	this.Data["json"] = map[string]interface{}{
		"result":  true,
		"msg":     "success",
		"preview": rst,
		"refer":   nil,
	}

	this.ServeJson()
}
コード例 #14
0
ファイル: cache.go プロジェクト: KarlZeo/blog-1
func SetCache(key string, value interface{}, timeout int64) error {
	data, err := Encode(value)
	if err != nil {
		return err
	}

	err = cc.Put(key, data, timeout)
	if err != nil {
		log.Warnln("Cache失败,key:", key)
		return err
	} else {
		log.Blueln("Cache成功,key:", key)
		return nil
	}
}
コード例 #15
0
ファイル: init.go プロジェクト: kien8995/judger
func Judger() {
	parseArg()

	dataPath := "data.db"

	if Mode == "docker" {
		log.Blueln("[mode]", "docker")

		if !com.FileExist("/data") {
			if err := com.Mkdir("/data"); err != nil {
				log.Warnln("[Warn]", "create dir /data failed")
			} else {
				log.Blueln("[info]", "create dir /data")
			}
		}

		if !com.FileExist("/data/config_docker.ini") {
			com.CopyFile("/data/config_docker.ini", "conf/config_docker.ini")
		}

		if !com.FileExist("/data/executer.json") {
			com.CopyFile("/data/executer.json", "sandbox/c/build/executer.json")
		}

		dataPath = "/data/data.db"
	}

	if configFile == "" {
		configFile = "conf/config.ini"
	}

	if !com.FileExist(configFile) {
		log.Dangerln("[Error]", configFile, "does not exist!")
		os.Exit(-1)
	}

	log.Blueln("[config]")
	log.Blueln(configFile)

	C = &Config{}
	C.NewConfig(configFile)

	GenScript()

	log.Blueln("[data]")
	log.Blueln(dataPath)
	DB = &Sqlite{}
	DB.NewSqlite(dataPath)

	createBuildDir()

	go TcpStart()
	HttpStart()
}
コード例 #16
0
ファイル: base.go プロジェクト: jango2015/ojsite
// run before get
func (this *BaseController) Prepare() {
	// get user level
	var lev string

	stn := time.Now()
	st := stn.UnixNano()
	this.Data["start"] = st

	log.Blueln(this.Ctx.Request.UserAgent())

	user := this.GetSession("username")
	if user == nil {
		lev = "guest" // guest, not login
	} else {
		level := this.GetSession("level")

		if level == nil {
			lev = "user"
		} else {
			if tmplev, ok := level.(string); !ok {
				lev = "user"
			} else {
				lev = tmplev
			}
		}

		username := user.(string)
		usr := models.User{}
		u, err := usr.GetUser(0, username, "", "")
		if err != nil {
			this.Data["nickname"] = ""
			this.Data["email_md5"] = ""
		} else {
			this.Data["username"] = username
			this.Data["nickname"] = u.Nickname
			this.Data["email_md5"] = com.Md5(u.Email)
		}

	}

	this.Data["userIs"] = lev

	// log.Pinkln(lev)
}
コード例 #17
0
ファイル: profile.go プロジェクト: jango2015/ojsite
func (this *ProfileController) Get() {
	username := this.Ctx.Input.Param(":username")

	ip := this.Ctx.Input.IP()
	log.Blueln(ip)

	if this.Data["userIs"] == "guest" {
		user := &models.User{}
		u, _ := user.GetUser(0, username, "", "")

		this.Data["title"] = u.Nickname + this.Lang("title_profile")

	} else {
		this.Data["title"] = this.Data["nickname"].(string) + this.Lang("title_profile")
	}

	this.TplNames = "user/profile.tpl"

}
コード例 #18
0
ファイル: task.go プロジェクト: jango2015/ojsite
func reconnect() {
	host := beego.AppConfig.String("judgerhost")
	port, err := beego.AppConfig.Int("judgerport")
	pass := beego.AppConfig.String("judgerpass")

	if err != nil {
		port = 1004
	}

	jdg := judger.Get("default")
	err = jdg.Start(host, port, pass)

	if err != nil {
		log.Warnln("Reconnect Failed", err)
	} else {
		log.Blueln("Reconnected.")
	}

}
コード例 #19
0
ファイル: conf_test.go プロジェクト: elago/ela
func TestConfig(t *testing.T) {
	Convey("Test Config sections", t, func() {
		conf := NewConfig("etc/test.ini")
		content, err := conf.readConfigFile()
		if err != nil {
			log.Redln(err)
		} else {
			log.Greenln("raw content")
			log.Pinkln("==============")

			log.Blueln(content)
			content = conf.filterComment()

			log.Greenln("filter comment")
			log.Pinkln("==============")

			log.Blueln(content)
			arraylize := conf.arraylize()

			log.Greenln("arraylize")
			log.Pinkln("==============")
			count := len(arraylize)
			log.Bluef("[%d]\n", count)
			for i := 0; i < count; i++ {
				log.Bluef("[%d]\t%s\n", i, arraylize[i])
			}

			log.Greenln("parse items")
			log.Pinkln("==============")
			conf.parseItems()

			log.Greenln("warning stack")
			log.Pinkln("==============")
			log.Blueln(conf.GetWarnings())

			log.Greenln("mistake value")
			log.Pinkln("==============")
			log.Blueln(conf.GetString("mysql", "host"))

			log.Greenln("about bool")
			log.Pinkln("==============")
			conf.SetBool("test", "dev", true)
			dev, _ := conf.GetBool("_", "dev")
			log.Blueln("%v", dev)

			content = conf.serialize()
			log.Greenln("serialize value")
			log.Pinkln("==============")
			log.Blueln(content)

			log.Greenln("hex")
			log.Pinkln("==============")
			hex, _ := conf.GetInt("_", "hex")
			log.Blueln(hex)

			log.Greenln("get empty")
			log.Pinkln("==============")
			_, err = conf.GetInt("_", "heloo")
			if err != nil {
				log.Blueln(err)
			}

			log.Greenln("save config file")
			log.Pinkln("==============")
			err := conf.Save("tmp/test.ini")
			if err == nil {
				log.Blueln("done!")
			}

		}

		val1, _ := conf.Get("_", "port")
		So(val1, ShouldEqual, 80)

		val2, _ := conf.GetString("_", "appname")
		So(val2, ShouldEqual, "my application")

		val3, _ := conf.GetString("mysql", "password")
		So(val3, ShouldEqual, "\"liju")

		val4, _ := conf.GetString("mysql", "host")
		So(val4, ShouldEqual, `"192.168.1.11" = GHJ`)

		val5, _ := conf.GetBool("_", "dev")
		So(val5, ShouldEqual, true)

		val6, _ := conf.GetFloat("_", "pi")
		So(val6, ShouldEqual, 3.14)

		val7, _ := conf.GetInt("_", "hex")
		So(val7, ShouldEqual, 0x24)

		val8 := conf.GetIntDefault("section", "key", 100)
		So(val8, ShouldEqual, 100)

		val9 := conf.GetStringDefault("mysql", "key", "")
		So(val9, ShouldEqual, "")
	})
}
コード例 #20
0
ファイル: tcp.go プロジェクト: kien8995/judger
// send message to client and print in server console
func (this *Client) Write(str string) {
	str = str + MARK
	this.Conn.Write([]byte(str))
	log.Blueln(str)
}
コード例 #21
0
ファイル: problem.go プロジェクト: jango2015/ojsite
// uri /api/problem/list/:page
func (this *ProblemListController) Get() {
	page, err := this.GetInt("page")
	if nil != err || page < 0 {
		page = 0
	}

	s := this.Ctx.Input.Param(":page")
	pageParm, err := strconv.Atoi(s)
	if nil != err || pageParm < 0 {
		pageParm = 0
	} else {
		page = pageParm
	}

	if 0 == page {
		page = 1
	}

	status := this.GetString("status")
	if len(status) <= 0 {
		status = "ok"
	}

	if status == "ok" {
		pro := models.Problem{}
		data, hasNext, totalPage, err := pro.ListProblem(page, 20, "")

		if err != nil {
			this.Data["json"] = map[string]interface{}{
				"result":     false,
				"msg":        "get list failing",
				"list":       nil,
				"has_next":   false,
				"total_page": 0,
				"refer":      nil,
			}
		} else {
			log.Blueln(data)

			this.Data["json"] = map[string]interface{}{
				"result":     true,
				"msg":        "get list success",
				"list":       data,
				"has_next":   hasNext,
				"total_page": totalPage,
				"refer":      nil,
			}
		}
	} else {
		if status != "audit" && status != "ok" && status != "deleted" {
			this.Data["json"] = map[string]interface{}{
				"result":     false,
				"msg":        "invalid status",
				"list":       nil,
				"has_next":   false,
				"total_page": 0,
				"refer":      nil,
			}
		} else {

			pro := models.ProblemBank{}
			data, hasNext, totalPage, err := pro.ListProblem(page, 20, status)

			if err != nil {
				this.Data["json"] = map[string]interface{}{
					"result":     false,
					"msg":        "get list failing",
					"list":       nil,
					"has_next":   false,
					"total_page": 0,
					"refer":      nil,
				}
			} else {
				log.Blueln(data)

				this.Data["json"] = map[string]interface{}{
					"result":     true,
					"msg":        "get list success",
					"list":       data,
					"has_next":   hasNext,
					"total_page": totalPage,
					"refer":      nil,
				}
			}
		}
	}

	this.ServeJson()
}