Beispiel #1
0
func (c *Cursor) ResetFetch() error {
	var e error
	c.Connection().(*Connection).Close()
	e = c.Connection().(*Connection).Connect()

	if e != nil {
		return errorlib.Error(packageName, modCursor, "Restart Connection", e.Error())
	}

	c.headerColumn = c.Connection().(*Connection).headerColumn
	c.file = c.Connection().(*Connection).file
	c.reader = c.Connection().(*Connection).reader

	e = c.prepIter()
	if e != nil {
		return errorlib.Error(packageName, modCursor, "ResetFetch", e.Error())
	}

	// c.PrepareCursor()
	// if e != nil {
	// 	return errorlib.Error(packageName, modCursor, "Prepare Cursor", e.Error())
	// }

	return nil
}
Beispiel #2
0
func (q *Query) HasPartExec() error {
	var jsonString []byte
	var err error
	if q.hasNewSave {
		jsonString, err = json.MarshalIndent(q.sliceData, "", "  ")
		if err != nil {
			return errorlib.Error(packageName, modQuery+".Exec", "Has part exec Marshal JSON", err.Error())
		}
	} else if q.hasSave {
		lastJson := q.Connection().(*Connection).getJsonToMap
		var allJsonData toolkit.Ms
		allJsonData = append(lastJson, q.sliceData...)

		jsonString, err = json.MarshalIndent(allJsonData, "", "  ")
		if err != nil {
			return errorlib.Error(packageName, modQuery+".Exec", "Has part exec Marshal JSON", err.Error())
		}
	}

	err = ioutil.WriteFile(q.Connection().(*Connection).filePath, jsonString, 0666)
	if err != nil {
		return errorlib.Error(packageName, modQuery+".Exec", "Write file", err.Error())
	}
	return nil
}
Beispiel #3
0
func Search(s SshSetting, path string, isParseble bool, search string) (string, error) {
	if path == "" {
		return "", errorlib.Error("", "", "SEARCH", "Path is Undivined")
	}

	if search == "" {
		return "", errorlib.Error("", "", "SEARCH", "Search param is undivined")
	}

	cmd := ""

	if isParseble {
		cmd = fmt.Sprintf(SEARCH_PARAM, path, search)
	} else {
		cmd = fmt.Sprintf(SEARCH, path, search)
	}

	res, e := s.GetOutputCommandSsh(cmd)

	if e != nil {
		e = errorlib.Error("", "", "SEARCH", e.Error())
	}

	return res, e
}
Beispiel #4
0
func (c *Connection) Connect() error {
	c.Close()

	ci := c.Info()

	if ci == nil || ci.Host == "" {
		return errorlib.Error(packageName, modConnection, "Connect", "No connection info")
	}

	_, e := os.Stat(ci.Host)
	if ci.Settings != nil {
		if ci.Settings["newfile"] == true {
			if os.IsNotExist(e) {
				create, _ := os.Create(ci.Host)
				create.Close()
			}
		} else {
			if os.IsNotExist(e) {
				return errorlib.Error(packageName, modConnection, "Connect", "Create new file is false")
			}
		}
	} else if os.IsNotExist(e) {
		return errorlib.Error(packageName, modConnection, "Connect", "No json file found")
	}

	c.filePath = ci.Host

	defaultPath, fileName, sep := c.GetBaseFilepath()
	c.basePath = defaultPath
	c.baseFileName = fileName
	c.separator = sep

	return nil
}
Beispiel #5
0
func List(s SshSetting, path string, isParseble bool) (string, error) {
	if path == "" {
		return "", errorlib.Error("", "", "LIST", "Path is Undivined")
	}

	cmd := ""

	if isParseble {
		cmd = fmt.Sprintf(LIST_PARAM, path)
	} else {
		cmd = fmt.Sprintf(LIST, path)
	}

	res, e := s.GetOutputCommandSsh(cmd)

	if e != nil {
		e = errorlib.Error("", "", "LIST", e.Error())
	}

	startStr := strings.Index(res, "\n")

	if res != "" {
		return res[startStr:], e
	}

	return res, e
}
Beispiel #6
0
func Chmod(s SshSetting, path string, permission string, format bool) (e error) {
	if format {
		permission, e = constructPermission(permission)
		if e != nil {
			return errorlib.Error("", "", "CHMOD", e.Error())
		}
	}

	if path == "" {
		return errorlib.Error("", "", "CHMOD", "Path is Undivined")
	}

	if permission == "" {
		return errorlib.Error("", "", "CHMOD", "Permission is Undivined")
	}

	cmd := fmt.Sprintf(CHMOD, permission, path)
	_, e = s.GetOutputCommandSsh(cmd)

	if e != nil {
		return errorlib.Error("", "", "CHMOD", e.Error())
	}

	return e
}
Beispiel #7
0
func Remove(s SshSetting, recursive bool, paths ...string) map[string]error {
	var es map[string]error

	if len(paths) < 1 {
		es[""] = errorlib.Error("", "", "REMOVE", "Paths is Undivined")
		return es
	}

	for _, path := range paths {
		cmd := ""
		if recursive {
			cmd = fmt.Sprintf(REMOVE_RECURSIVE, path)
		} else {
			cmd = fmt.Sprintf(REMOVE, path)
		}

		_, e := s.GetOutputCommandSsh(cmd)

		if e != nil {
			if es == nil {
				es = map[string]error{}
			}
			es[path] = errorlib.Error("", "", "REMOVE", e.Error())
		}
	}
	return es
}
Beispiel #8
0
func MakeFile(s SshSetting, content string, path string, permission string, format bool) error {
	if path == "" {
		return errorlib.Error("", "", "MAKEFILE", "Path is Undivined")
	}

	cmd := fmt.Sprintf(MKFILE, content, path)
	_, e := s.GetOutputCommandSsh(cmd)

	if e != nil {
		return errorlib.Error("", "", "MAKEFILE", e.Error())
	}

	if permission == "" {
		permission = "755"
		format = false
	}

	e = Chmod(s, path, permission, format)

	if e != nil {
		return errorlib.Error("", "", "MAKEFILE", e.Error())
	}

	return e
}
Beispiel #9
0
func (c *Connection) OpenSession() error {
	c.Close()

	t, e := os.OpenFile(c.filePath, os.O_RDWR, 0)
	if e != nil {
		return errorlib.Error(packageName, modConnection, "Open File", e.Error())
	}
	c.openFile = t

	i, e := ioutil.ReadFile(c.filePath)
	if e != nil {
		return errorlib.Error(packageName, modQuery+".Exec", "Read file", e.Error())
	}

	var hoomanJson []toolkit.M
	e = toolkit.Unjson(i, &hoomanJson)
	if e != nil {
		return errorlib.Error(packageName, modQuery+".Exec", "Cannot Unjson", e.Error())
	}

	c.lines = 0
	c.sData = ""
	c.sameId = false
	if len(hoomanJson) == 0 {
		c.isNewSave = true
	} else {
		c.getJsonToMap = hoomanJson
	}

	return nil
}
Beispiel #10
0
func (c *Connection) RdbmsConnect(drivername string, stringConnection string) error {
	if drivername == "hive" {
		connInfo := strings.Split(stringConnection, ",")
		c.Hive = hive.HiveConfig(connInfo[0], connInfo[1], connInfo[2], connInfo[3], connInfo[4], connInfo[5])
		c.Drivername = drivername
		c.Hive.Conn.Open()
		e := c.Hive.Conn.TestConnection()
		if e != nil {
			return err.Error(packageName, modConnection, "Connect", e.Error())
		}
	} else {
		sqlcon, e := sql.Open(drivername, stringConnection)
		if e != nil {
			return err.Error(packageName, modConnection, "Connect", e.Error())
		}
		c.Sql = *sqlcon
		c.Drivername = drivername
		e = sqlcon.Ping()
		if e != nil {
			return err.Error(packageName, modConnection, "Connect", e.Error())
		}
	}
	if c.Info().Settings.Has("dateformat") {
		c.DateFormat = toolkit.ToString(c.Info().Settings.Get("dateformat", ""))
	}

	return nil
}
Beispiel #11
0
func (l *ConfigListBase) Load() error {
	e := l.Self().Validate()
	if e != nil {
		return e
	}

	if l.Self().NewItem() == nil {
		return err.Error(packageName, objConfigList, "Load", "No implementation of NewItem()")
	}

	fis, e := ioutil.ReadDir(l.configFolder)
	if e != nil {
		return err.Error(packageName, objConfigList, "Load", e.Error())
	}

	l.Inititems()
	for _, fi := range fis {
		item := l.Self().NewItem()
		e = NewFromFile(filepath.Join(l.configFolder, fi.Name()), item)
		if e == nil {
			l.Set(item)
		}
	}

	return nil
}
Beispiel #12
0
func Chown(s SshSetting, path string, user string, group string, recursive bool) error {
	if path == "" {
		return errorlib.Error("", "", "CHOWN", "Path is Undivined")
	}

	if user == "" {
		return errorlib.Error("", "", "CHOWN", "User is Undivined")
	}

	if group == "" {
		return errorlib.Error("", "", "CHOWN", "Group is Undivined")
	}

	cmd := ""

	if recursive {
		cmd = fmt.Sprintf(CHOWN_RECURSIVE, user, group, path)
	} else {
		cmd = fmt.Sprintf(CHOWN, user, group, path)
	}

	_, e := s.GetOutputCommandSsh(cmd)

	if e != nil {
		return errorlib.Error("", "", "CHOWN", e.Error())
	}

	return e
}
Beispiel #13
0
func (d *DataContext) setConnectionFromConfigFile(name string) error {
	d.ConnectionName = name
	if d.ConnectionName == "" {
		d.ConnectionName = fmt.Sprintf("Default")
	}

	connType := strings.ToLower(config.Get("Connection_" + d.ConnectionName + "_Type").(string))
	host := config.Get("Connection_" + d.ConnectionName + "_Host").(string)
	username := config.Get("Connection_" + d.ConnectionName + "_Username").(string)
	password := config.Get("Connection_" + d.ConnectionName + "_Password").(string)
	database := config.Get("Connection_" + d.ConnectionName + "_database").(string)

	ci := new(dbox.ConnectionInfo)
	ci.Host = host
	ci.UserName = username
	ci.Password = password
	ci.Database = database

	conn, eConnect := dbox.NewConnection(connType, ci)
	if eConnect != nil {
		return err.Error(packageName, modCtx, "SetConnectionFromConfigFile", eConnect.Error())
	}
	if eConnect = conn.Connect(); eConnect != nil {
		return err.Error(packageName, modCtx, "SetConnectionFromConfigFile", eConnect.Error())
	}
	d.Connection = conn
	return nil
}
Beispiel #14
0
func (q *Query) Cursor(in toolkit.M) (dbox.ICursor, error) {
	var cursor *Cursor

	setting, e := q.prepare(in)
	if e != nil {
		return nil, err.Error(packageName, modQuery, "Cursor", e.Error())
	}

	commandtype := setting.GetString("commandtype")
	if commandtype != dbox.QueryPartSelect {
		return nil, err.Error(packageName, modQuery, "Cursor", "Cursor is only working with select command, for "+commandtype+" please use .Exec instead")
	}

	e = q.openFile()
	if e != nil {
		return nil, err.Error(packageName, modQuery, "Cursor", e.Error())
	}
	//toolkit.Printf("Data count: %d \n", len(q.data))
	cursor = newCursor(q)
	where := setting.Get("where", []*dbox.Filter{}).([]*dbox.Filter)
	if len(where) > 0 {
		cursor.where = where
		cursor.indexes = dbox.Find(q.data, where)
	}
	return cursor, nil
}
Beispiel #15
0
func (q *Query) openFile() error {
	if q.fileHasBeenOpened {
		return nil
	}

	_, e := os.Stat(q.jsonPath)
	if e != nil && (strings.Contains(e.Error(), "does not exist") || strings.Contains(e.Error(), "no such file or directory")) {
		q.data = []toolkit.M{}
		return nil
	} else if e != nil {
		return err.Error(packageName, modQuery, "openFile: Open file fail", e.Error())
	}
	bs, e := ioutil.ReadFile(q.jsonPath)
	if e != nil {
		return err.Error(packageName, modQuery, "openFile: Read file data fail", e.Error())
	}
	jsonText := string(bs)
	var tempData []toolkit.M
	e = toolkit.UnjsonFromString(jsonText, &tempData)
	if e != nil {
		return err.Error(packageName, modQuery, "openFile: Serializaion fail", e.Error())
	}
	q.data = tempData

	q.fileHasBeenOpened = true
	return nil
}
Beispiel #16
0
func (q *Query) Cursor(in toolkit.M) (dbox.ICursor, error) {
	var cursor *Cursor

	setting, e := q.prepare(in)
	if e != nil {
		return nil, err.Error(packageName, modQuery, "Cursor", e.Error())
	}

	if setting.GetString("commandtype") != dbox.QueryPartSelect {
		return nil, err.Error(packageName, modQuery, "Cursor", "Cursor is only working with select command, please use .Exec instead")
	}

	e = q.openFile()
	if e != nil {
		return nil, err.Error(packageName, modQuery, "Cursor", e.Error())
	}

	cursor = newCursor(q)
	where := setting.Get("where", []*dbox.Filter{}).([]*dbox.Filter)
	// toolkit.Println("LINE 56 : ", where)
	cursor.skip = setting.Get("skip", 0).(int)
	cursor.limit = setting.Get("take", 0).(int)
	cursor.fields = setting.Get("fields", toolkit.M{}).(toolkit.M)

	// if len(where) > 0 {
	cursor.where = where
	cursor.indexes, e = q.generateIndex(where)
	if e != nil {
		return nil, err.Error(packageName, modQuery, "Cursor", e.Error())
	}
	// }

	return cursor, nil
}
Beispiel #17
0
func (c *Cursor) Fetch(m interface{}, n int, closeWhenDone bool) error {
	if closeWhenDone {
		defer c.Close()
	}

	e := c.prepIter()
	if e != nil {
		return errorlib.Error(packageName, modCursor, "Fetch", e.Error())
	}

	if c.mgoIter == nil {
		return errorlib.Error(packageName, modCursor, "Fetch", "Iter object is not yet initialized")
	}

	if !IsPointer(m) {
		return errorlib.Error(packageName, modCursor, "Fetch", "Model object should be pointer")
	}

	//ds := dbox.NewDataSet(m)
	//	var datas []interface{}
	//	rt := reflect.TypeOf(m)
	//datias := reflect.MakeSlice(rt, 0, 0)
	if n == 0 {
		//datas := []interface{}{}
		e = c.mgoIter.All(m)
		if e != nil {
			return errorlib.Error(packageName, modCursor,
				"Fetch", e.Error())
		}
		//ds.Data = datas
	} else if n == 1 {
		c.mgoIter.Next(m)
	} else if n > 1 {
		fetched := 0
		fetching := true
		for fetching {
			dataHolder, e := GetEmptySliceElement(m)
			if e != nil {
				return errorlib.Error(packageName, modCursor, "Fetch", e.Error())
			}
			var bOk bool
			if IsPointer(dataHolder) {
				bOk = c.mgoIter.Next(dataHolder)
			} else {
				bOk = c.mgoIter.Next(&dataHolder)
			}
			if bOk {
				AppendSlice(m, dataHolder)
				fetched++
				if fetched == n {
					fetching = false
				}
			} else {
				fetching = false
			}
		}
	}

	return nil
}
Beispiel #18
0
func (q *Query) execQueryPartUpdate(dt toolkit.M, Cond QueryCondition) error {

	if len(dt) == 0 {
		return errorlib.Error(packageName, "Query", modQuery, "data to update is not found")
	}

	writer := q.Connection().(*Connection).writer
	reader := q.Connection().(*Connection).reader
	tempHeader := []string{}

	for _, val := range q.Connection().(*Connection).headerColumn {
		tempHeader = append(tempHeader, val.name)
	}

	for {
		foundChange := false

		recData := toolkit.M{}
		dataTemp, e := reader.Read()
		for i, val := range dataTemp {
			recData.Set(tempHeader[i], val)
		}

		if len(Cond.Find) > 0 || (len(Cond.Find) == 0 && toolkit.IdField(dt) == "") {
			foundChange = Cond.getCondition(recData)
		}

		// Check ID IF Condition Not Found
		if nameid := toolkit.IdField(dt); nameid != "" && !foundChange {
			if recData.Has(nameid) && dt[nameid] == recData[nameid] {
				foundChange = true
			}
		}

		if foundChange && len(dataTemp) > 0 {
			for n, v := range tempHeader {
				if dt.Has(v) {
					dataTemp[n] = cast.ToString(dt[v])
				}
			}
		}

		if e == io.EOF {
			if dataTemp != nil {
				writer.Write(dataTemp)
				writer.Flush()
			}
			break
		} else if e != nil {
			return errorlib.Error(packageName, modQuery, "Update", e.Error())
		}
		if dataTemp != nil {
			writer.Write(dataTemp)
			writer.Flush()
		}
	}

	return nil
}
Beispiel #19
0
func (q *Query) Cursor(in toolkit.M) (dbox.ICursor, error) {
	var cursor *Cursor

	setting, e := q.prepare(in)

	if e != nil {
		return nil, err.Error(packageName, modQuery, "Cursor", e.Error())
	}

	commandtype := setting.GetString("commandtype")
	if commandtype != dbox.QueryPartSelect {
		return nil, err.Error(packageName, modQuery, "Cursor", "Cursor is only working with select command, for "+commandtype+" please use .Exec instead")
	}

	e = q.openFile(commandtype)
	if e != nil {
		return nil, err.Error(packageName, modQuery, "Cursor", e.Error())
	}
	cursor = newCursor(q)

	skip := 0
	if skip = setting.Get("skip").(int); skip > 0 {
		cursor.skip = skip
	}

	take := 0
	if take = setting.Get("take").(int); take > 0 {
		cursor.take = take
	}
	if sort := setting.Get("sort").([]string); toolkit.SliceLen(sort) > 0 {
		fb := new(json.FilterBuilder)
		sorter := fb.SortFetch(sort, q.data)
		q.data = sorter
	}

	cursor.jsonSelect = setting.Get("fields").([]string)
	var count int
	count = toolkit.SliceLen(q.data)
	where := setting.Get("where", []*dbox.Filter{}).([]*dbox.Filter)
	if len(where) > 0 {
		cursor.where = where
		cursor.indexes = dbox.Find(q.data, where)
		count = toolkit.SliceLen(cursor.indexes)
	}
	if count <= skip {
		count = 0
	} else {
		count -= skip
	}
	if count >= take && take > 0 {
		count = take
	}
	cursor.count = count
	return cursor, nil
}
Beispiel #20
0
func (c *Connection) Execute(stmt string, parms M) (int, error) {
	var e error
	if parms == nil {
		parms = M{}
	}
	pooling := parms.Get("pooling", false).(bool)

	var sess *mgo.Session
	var coll *mgo.Collection
	if pooling {
		sess = c.mses
		coll = c.mses.DB(c.Database).C(stmt)
	} else {
		sess, coll = c.CopySession(stmt)
		defer sess.Close()
	}
	//sess = c.mses

	//coll := c.mdb.C(stmt)
	var op DB_OP
	ok := true
	if val, ok := parms["operation"]; !ok {
		return 0, err.Error(packageName, modConnection, "Execute", "Invalid operation in parms")
	} else {
		op = val.(DB_OP)
	}

	var data interface{}
	if data, ok = parms["data"]; !ok && op != DB_DELETE {
		return 0, err.Error(packageName, modConnection, "Execute", "Data is not valid")
	}

	if op == DB_INSERT {
		e = coll.Insert(data)
		if e != nil {
			return 0, err.Error(packageName, modConnection, "Execute - Insert", e.Error())
		}
	} else {
		find, _ := parms["find"]
		if op == DB_SAVE {
			_, e = coll.Upsert(find, data)
		} else if op == DB_UPDATE {
			e = coll.Update(find, data)
		} else if op == DB_DELETE {
			_, e = coll.RemoveAll(find)
		} else {
			op = DB_UKNOWN
		}
		//_ = "breakpoint"
		if e != nil {
			return 0, err.Error(packageName, modConnection, "Execute - "+string(op), e.Error())
		}
	}
	return 0, nil
}
func (s *Sequence) Save() error {
	if Ctx == nil {
		return errorlib.Error(packageName, objSequence, "Save", "Context not yet initialized")
	}

	e := Ctx.Save(s)
	if e != nil {
		return errorlib.Error(packageName, objSequence, "Save", e.Error())
	}
	return nil
}
func (s *Sequence) ChangeNumberStatus(n int, status NumberStatus) error {
	if Ctx == nil {
		return errorlib.Error(packageName, objSequence, "ChangeNumberStatus", "Context not yet initialized")
	}
	used := NewUsedSequence(s.Id, n, status)
	e := Ctx.Save(used)
	if e != nil {
		return errorlib.Error(packageName, objSequence, "ChangeNumberStatus", e.Error())
	}
	return nil
}
Beispiel #23
0
func NewConnection(connector string, ci *ConnectionInfo) (IConnection, error) {
	if connectors == nil {
		return nil, errorlib.Error(packageName, "", "NewConnection", "Invalid connector")
	}

	fn, found := connectors[connector]
	if found == false {
		return nil, errorlib.Error(packageName, "", "NewConnection", "Invalid connector")
	}
	return fn(ci)
}
Beispiel #24
0
func (l *ConfigListBase) Validate() error {
	if _, e := os.Stat(l.configFolder); e != nil {
		if os.IsNotExist(e) {
			return err.Error(packageName, objConfigList, "Validate",
				fmt.Sprintf("Directory %s is not exitst", l.configFolder))
		} else {
			return err.Error(packageName, objConfigList, "Validate", e.Error())
		}
	}

	return nil
}
Beispiel #25
0
func (q *Query) Statement() (toolkit.M, error) {
	toolkit.Println(q.QStatement)
	out := toolkit.M{}
	tableData := toolkit.Ms{}
	fieldName := []string{}
	q.DateFormat = q.Connection().(*Connection).dateFormat

	// stmt, e := q.Connection().(*Connection).OdbcCon.Prepare(query)
	stmt, e := q.Connection().(*Connection).Sess.Prepare(q.QStatement)
	if e != nil {
		return nil, err.Error(packageName, modQuery, "statement", e.Error())
	}
	defer stmt.Close()

	e = stmt.Execute()
	if e != nil {
		return nil, err.Error(packageName, modQuery, "statement", e.Error())
	}

	rows, e := stmt.FetchAll()
	if e != nil {
		return nil, err.Error(packageName, modQuery, "statement", e.Error())
	}

	nfields, e := stmt.NumFields()
	if e != nil {
		return nil, err.Error(packageName, modQuery, "statement", e.Error())
	}

	for i := 0; i < nfields; i++ {
		field, e := stmt.FieldMetadata(i + 1)
		if e != nil {
			return nil, err.Error(packageName, modQuery, "statement", e.Error())
		}
		fieldName = append(fieldName, field.Name)
	}

	for _, row := range rows {
		entry := toolkit.M{}
		for i := 0; i < len(row.Data); i++ {

			data := q.DataType(row.Data[i])
			entry.Set(fieldName[i], data)
		}

		tableData = append(tableData, entry)
	}

	out.Set("count", len(rows))
	out.Set("data", tableData)

	return out, nil
}
Beispiel #26
0
func (q *Query) execQueryPartUpdate(dt toolkit.M) error {
	var e error
	e = q.startWriteMode()
	if e != nil {
		return err.Error(packageName, modQuery, "Exec-Update: ", e.Error())
	}

	writer := q.writer
	reader := q.reader
	tempHeader := []string{}

	for _, val := range q.headerColumn {
		tempHeader = append(tempHeader, val.name)
	}

	var i int = 0

	for {
		i += 1

		dataTemp, e := reader.Read()
		if toolkit.HasMember(q.indexes, i) && len(dataTemp) > 0 {
			for n, v := range tempHeader {
				if dt.Has(v) {
					dataTemp[n] = cast.ToString(dt[v])
				}
			}
		}

		if e == io.EOF {
			if len(dataTemp) > 0 {
				writer.Write(dataTemp)
				writer.Flush()
			}
			break
		} else if e != nil {
			_ = q.endWriteMode()
			return err.Error(packageName, modQuery, "Exec-Update:", e.Error())
		}
		if len(dataTemp) > 0 {
			writer.Write(dataTemp)
			writer.Flush()
		}
	}

	q.execOpr = true
	e = q.endWriteMode()
	if e != nil {
		return err.Error(packageName, modQuery, "Exec-Update: ", e.Error())
	}
	return nil
}
Beispiel #27
0
func (c *Connection) Connect() error {
	if c.Folder == "" {
		return err.Error(packageName, modConnection, "Connect", "Folder path is empty")
	}

	_, e := os.Stat(c.Folder)
	if e != nil {
		return err.Error(packageName, modConnection, "Connect",
			e.Error())
	}

	return nil
}
Beispiel #28
0
func Cat(s SshSetting, path string) (string, error) {
	if path == "" {
		return "", errorlib.Error("", "", "CAT", "Path is Undivined")
	}

	cmd := fmt.Sprintf(CAT, path)
	res, e := s.GetOutputCommandSsh(cmd)
	if e != nil {
		e = errorlib.Error("", "", "CAT", e.Error())
	}

	return res, e
}
Beispiel #29
0
func (c *Connection) CloseWriteSession() error {
	c.Close()

	eRem := os.Remove(c.filePath)
	if eRem != nil {
		return errorlib.Error(packageName, modQuery+".Exec", "Close Write Session", eRem.Error())
	}

	eRen := os.Rename(c.basePath+c.separator+"temp_"+c.baseFileName, c.filePath)
	if eRen != nil {
		return errorlib.Error(packageName, modQuery+".Exec", "Close Write Session", eRen.Error())
	}
	return nil
}
Beispiel #30
0
func (c *Cursor) ResetFetch() error {
	var e error
	e = c.resetConnection()
	if e != nil {
		return errorlib.Error(packageName, modCursor, "Reset Fetch", e.Error())
	}
	if len(c.ConditionVal.where) > 0 {
		e = c.generateIndexes()
		if e != nil {
			return errorlib.Error(packageName, modCursor, "Reset Fetch", e.Error())
		}
	}
	return nil
}