Golang bytengine.Command类代码示例

// grant/deny user database access parser
func (p *Parser) parseUserDatabaseAccessCmd(ctx string) {
	_token := p.expect(itemString, ctx)
	_user, err := formatString(_token.val)
	if err != nil {
		p.errorf("Improperly quoted username in %s", ctx)
	}
	_token = p.expect(itemString, ctx)
	_db, err2 := formatString(_token.val)
	if err2 != nil {
		p.errorf("Improperly quoted database in %s", ctx)
	}
	_token = p.expect(itemIdentifier, ctx)
	_grant := false
	switch _token.val {
	case "grant":
		_grant = true
	case "deny":
		// do nothing _grant already false
		break
	default:
		p.errorf("Invalid indentifier "+_token.val+" in %s", ctx)
	}
	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: true,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Args["username"] = _user
	cmd.Args["database"] = _db
	cmd.Args["grant"] = _grant
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// list directory contents parser
func (p *Parser) parseListDirectoryCmd(db, ctx string) {
	_token := p.expect(itemPath, ctx)
	_path := _token.val
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["path"] = _path

	// parse arguments
	ac := newOptList()
	ac.Add("regex", optString)
	p.parseOptions(ctx, ac)
	// get arguments
	arg := ac.Get("regex")
	if arg != nil {
		cmd.Options["regex"] = arg
	}

	_filter := p.parseEndofCommand(ctx)
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// initialize bytengine parser
func (p *Parser) parseServerInitCmd(ctx string) {
	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: true,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// read file JSON content parser
func (p *Parser) parseReadFileCmd(db, ctx string) {
	_token := p.expect(itemPath, ctx)
	_path := _token.val
	// check if we have an array of fields to return
	_list := []string{}
	if p.peek().typ == itemLeftBracket {
		// parse array and make sure all elements are strings
		// absorb left bracket
		p.next()
		// check type of next token
	Loop:
		for {
			switch p.peek().typ {
			case itemString:
				_next := p.next()
				_val, err := formatString(_next.val)
				if err != nil {
					p.errorf("Improperly quoted string value in %s Array definition.", ctx)
				}
				_list = append(_list, _val)
				continue
			case itemComma:
				// absorb comma
				p.next()
				if p.peek().typ == itemRightBracket {
					p.errorf("Trailing comma ',' in %s Array definition.", ctx)
				}
				continue
			case itemRightBracket:
				// absorb
				p.next()
				break Loop
			default:
				p.errorf("Invalid value: "+p.peek().val+" in %s Array definition.", ctx)
			}
		}
	}

	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["path"] = _path
	cmd.Args["fields"] = _list
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// delete file bytes parser
func (p *Parser) parseDeleteAttachmentCmd(db, ctx string) {
	_token := p.expect(itemPath, ctx)
	_path := _token.val
	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["path"] = _path
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// delete user parser
func (p *Parser) parseDropUserCmd(ctx string) {
	_token := p.expect(itemString, ctx)
	_user, err := formatString(_token.val)
	if err != nil {
		p.errorf("Improperly quoted username in %s", ctx)
	}
	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: true,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Args["username"] = _user
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// rename file/directory parser
func (p *Parser) parseRenameContentCmd(db, ctx string) {
	_token := p.expect(itemPath, ctx)
	_path := _token.val
	_token = p.expect(itemString, ctx)
	_name, err := formatString(_token.val)
	if err != nil {
		p.errorf("Improperly quoted new name in %s", ctx)
	}
	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["path"] = _path
	cmd.Args["name"] = _name
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

func getUploadTicketHandler(ctx *gin.Context) {
	var form struct {
		Token    string `form:"token" binding:"required"`
		Database string `form:"database" binding:"required"`
		Path     string `form:"path" binding:"required"`
	}
	ok := ctx.Bind(&form)
	if ok != nil {
		data := errorResponse(errors.New("Missing parameters"))
		ctx.Data(400, "application/json", data)
		return
	}

	cmd := bytengine.Command{
		Name:    "uploadticket",
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = form.Database
	cmd.Args["path"] = form.Path

	duration := Configuration.Timeout.UploadTicket // in minutes
	cmd.Args["duration"] = duration

	req := EngineRequest{
		Token:        form.Token,
		Command:      &cmd,
		ResponseChan: make(chan EngineResponse),
	}
	EngineRequestChan <- &req
	rep := <-req.ResponseChan
	if rep.Error != nil {
		data := errorResponse(rep.Error)
		ctx.Data(400, "application/json", data)
		return
	}

	ctx.Data(200, "application/json", okResponse(rep.Response))
}

// list users parser
func (p *Parser) parseListUsersCmd(ctx string) {
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: true,

		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{})} // check if regex option has been added

	// parse arguments
	ac := newOptList()
	ac.Add("regex", optString)
	p.parseOptions(ctx, ac)
	// get arguments
	arg := ac.Get("regex")
	if arg != nil {
		cmd.Options["regex"] = arg
	}

	_filter := p.parseEndofCommand(ctx)
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

func downloadFileHandler(ctx *gin.Context) {
	var form struct {
		Token    string `form:"token" binding:"required"`
		Database string `form:"database" binding:"required"`
		Path     string `form:"path" binding:"required"`
	}
	ok := ctx.Bind(&form)
	if ok != nil {
		data := errorResponse(errors.New("Missing parameters"))
		ctx.Data(400, "application/json", data)
		return
	}

	cmd := bytengine.Command{
		Name:    "readbytes",
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = form.Database
	cmd.Args["path"] = form.Path
	cmd.Args["writer"] = ctx.Writer

	ctx.Writer.Header().Set("Content-Type", "application/octet-stream")
	req := EngineRequest{
		Token:        form.Token,
		Command:      &cmd,
		ResponseChan: make(chan EngineResponse),
	}
	EngineRequestChan <- &req
	rep := <-req.ResponseChan
	if rep.Error != nil {
		data := errorResponse(rep.Error)
		ctx.String(400, string(data))
		return
	}
}

// overwrite file JSON parser
func (p *Parser) parseModifyFileCmd(db, ctx string) {
	_token := p.expect(itemPath, ctx)
	_path := _token.val

	// check if next item is a json object
	var _json interface{}
	if p.peek().typ == itemLeftBrace {
		_json = p.parseJSON(ctx)
	} else {
		p.errorf("Expecting a JSON object in %s", ctx)
	}
	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["path"] = _path
	cmd.Args["data"] = _json
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// copy file/directory parser
func (p *Parser) parseCopyContentCmd(db, ctx string) {
	_token := p.expect(itemPath, ctx)
	_path := _token.val
	_token = p.expect(itemPath, ctx)
	_path2 := _token.val
	_rename := ""
	if p.peek().typ == itemString {
		_nxt := p.next()
		_rename = _nxt.val
	}
	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["path"] = _path
	cmd.Args["to"] = _path2
	cmd.Args["rename"] = _rename
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// select query statement parser
func (p *Parser) parseSelectCmd(db, ctx string) {
	_fields := []string{}
	// get fields
	for p.peek().typ == itemString {
		_token := p.next()
		_field, err := formatString(_token.val)
		if err != nil {
			p.errorf("Improperly quoted field name in %s", ctx)
		}
		_fields = append(_fields, FieldPrefix+_field)
		continue
	}
	// get directories
	_in := p.expect(itemIdentifier, ctx)
	if strings.ToLower(_in.val) != "in" {
		p.errorf("Invalid %s, expecting 'In statement'.", ctx)
	}
	_paths := []string{}
	for p.peek().typ == itemPath {
		_path := p.next().val
		_paths = append(_paths, _path)
		continue
	}
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["fields"] = _fields
	cmd.Args["dirs"] = _paths
	var _filter string

	// get optional identifiers
Loop:
	for {
		switch _token := p.next(); {
		case _token.typ == itemIdentifier && strings.ToLower(_token.val) == "where":
			_where := p.parseWhereCmd()
			cmd.Args["where"] = _where
			continue
		case _token.typ == itemIdentifier && strings.ToLower(_token.val) == "sort":
			cmd.Args["sort"] = p.parseSortCmd()
			continue
		case _token.typ == itemIdentifier && strings.ToLower(_token.val) == "limit":
			// add to select statement
			cmd.Args["limit"] = p.parseLimitCmd()
			continue
		case _token.typ == itemIdentifier && strings.ToLower(_token.val) == "distinct":
			// add to select statement
			cmd.Args["distinct"] = p.parseDistinctCmd()
			continue
		case _token.typ == itemIdentifier && strings.ToLower(_token.val) == "count":
			cmd.Args["count"] = true
			continue
		case _token.typ == itemSendTo:
			p.backup()
			_filter = p.parseEndofCommand(ctx)
			break Loop
		case _token.typ == itemSemiColon:
			break Loop
		case _token.typ == itemEOF:
			p.backup()
			break Loop
		default:
			p.errorf("Invalid identifier "+_token.val+" in %s", ctx)
		}
	}

	// validate select statement
	_, hascount := cmd.Args["count"]
	_, haslimit := cmd.Args["limit"]
	_, hassort := cmd.Args["sort"]
	_, hasdistinct := cmd.Args["distinct"]

	if haslimit || hassort {
		if hascount {
			p.errorf("'Count' cannot be used with 'Limit' or 'Sort' in %s", ctx)
		}
		if hasdistinct {
			p.errorf("'Distinct' cannot be used with 'Limit' or 'Sort' in %s", ctx)
		}
	} else if hasdistinct {
		if haslimit {
			p.errorf("'Limit' cannot be used with 'Distinct' in %s", ctx)
		}
		if hassort {
			p.errorf("'Sort' cannot be used with 'Distinct' in %s", ctx)
		}
		if hascount {
			p.errorf("'Count' cannot be used with 'Distinct' in %s", ctx)
		}
	} else if hascount {
		if haslimit {
			p.errorf("'Limit' cannot be used with 'Count' in %s", ctx)
		}
		if hassort {
			p.errorf("'Sort' cannot be used with 'Count' in %s", ctx)
//.........这里部分代码省略.........

// increment/decrement/list counter parser
func (p *Parser) parseCounterCmd(db, ctx string) {
	_token := p.expectOneOf(itemString, itemIdentifier, ctx)
	if _token.typ == itemIdentifier {
		if _token.val == "list" {
			cmd := bytengine.Command{
				Name:    ctx,
				IsAdmin: false,
				Args:    make(map[string]interface{}),
				Options: make(map[string]interface{}),
			}
			cmd.Database = db
			cmd.Args["action"] = "list"

			// parse arguments
			ac := newOptList()
			ac.Add("regex", optString)
			p.parseOptions(ctx, ac)
			// get arguments
			arg := ac.Get("regex")
			if arg != nil {
				cmd.Options["regex"] = arg
			}

			_filter := p.parseEndofCommand(ctx)
			cmd.Filter = _filter
			p.commands = append(p.commands, cmd)
			return

		} else {
			p.errorf("Invalid identifier %s in %s", _token.val, ctx)
		}
	}

	_counter, err := formatString(_token.val)
	if err != nil {
		p.errorf("Improperly quoted counter name in %s", ctx)
	}
	_token = p.expect(itemIdentifier, ctx)
	_action := ""
	switch _token.val {
	case "incr":
		fallthrough
	case "decr":
		fallthrough
	case "reset":
		_action = _token.val
	default:
		p.errorf("Invalid indentifier "+_token.val+" in %s", ctx)
	}

	_token = p.expect(itemNumber, ctx)
	_val, err := strconv.ParseInt(_token.val, 10, 64) // base 10 64bit integer
	if err != nil {
		p.errorf("Invalid numerical value in %s", ctx)
	}

	_filter := p.parseEndofCommand(ctx)
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["name"] = _counter
	cmd.Args["action"] = _action
	cmd.Args["value"] = _val
	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}

// unset query statement parser
func (p *Parser) parseUnsetCmd(db, ctx string) {
	_fields := map[string]interface{}{}
	// get fields
	for p.peek().typ == itemString {
		_token := p.next()
		_field, err := formatString(_token.val)
		if err != nil {
			p.errorf("Improperly quoted field name in %s", ctx)
		}
		_field = FieldPrefix + _field
		_fields[_field] = 1
		continue
	}
	if len(_fields) < 1 {
		p.errorf("Invalid %s: no fields found", ctx)
	}

	// get directories
	_in := p.expect(itemIdentifier, ctx)
	if strings.ToLower(_in.val) != "in" {
		p.errorf("Invalid %s, expecting 'In statement'.", ctx)
	}
	_paths := []string{}
	for p.peek().typ == itemPath {
		_path := p.next().val
		_paths = append(_paths, _path)
		continue
	}
	cmd := bytengine.Command{
		Name:    ctx,
		IsAdmin: false,
		Args:    make(map[string]interface{}),
		Options: make(map[string]interface{}),
	}
	cmd.Database = db
	cmd.Args["fields"] = _fields
	cmd.Args["dirs"] = _paths
	var _filter string

	// get optional identifiers
Loop2:
	for {
		switch _token := p.next(); {
		case _token.typ == itemIdentifier && strings.ToLower(_token.val) == "where":
			_where := p.parseWhereCmd()
			cmd.Args["where"] = _where
			continue
		case _token.typ == itemSendTo:
			p.backup()
			_filter = p.parseEndofCommand(ctx)
			break Loop2
		case _token.typ == itemSemiColon:
			break Loop2
		case _token.typ == itemEOF:
			// do not consume eof
			p.backup()
			break Loop2
		default:
			p.errorf("Invalid identifier "+_token.val+" in %s", ctx)
		}
	}

	cmd.Filter = _filter
	p.commands = append(p.commands, cmd)
}