Golang ini.File类代码示例

func Serve(log *logging.Logger, addr string, ssl *ini.File) {
	var cmd []byte
	var ln net.Listener

	if ssl != nil {
		certificate := ssl.Section("ssl").Key("certificate").String()
		key := ssl.Section("ssl").Key("key").String()

		ln = tlsServe(log, addr, certificate, key)
		log.Debug("Opened SSL socket")
	} else {
		ln = plainServe(log, addr)
		log.Debug("Opened plain socket")
	}
	defer ln.Close()

	for {
		conn, err := ln.Accept()
		buff := bufio.NewReader(conn)

		if err != nil {
			// handle error
			log.Error("Error: %v\n", err)
		}
		log.Debug("Connection from " + conn.RemoteAddr().String() + " accepted")

		cmd, err = buff.ReadBytes('\n')
		log.Debug("Remote data readed")
		Parse(log, cmd, conn)
		conn.Close()
	}
}

func fileBackup(log *logging.Logger, section *common.Section, cfg *ini.File, c chan bool, wg *sync.WaitGroup) {
	defer func() {
		<-c
		wg.Done()
	}()

	dataset.DelDataset(log, cfg, section.Name, section.Grace, section.Dataset)

	log.Info("About to backup section " + section.Name)

	// Execute pre_command
	if err := execCommand(log, cfg.Section(section.Name), "pre_command"); err != nil {
		log.Debug(err.Error())
		// TODO: manage error
	}

	// Backup!
	backup.Filebackup(log, section, cfg)

	// Execute post_command
	if err := execCommand(log, cfg.Section(section.Name), "post_command"); err != nil {
		log.Debug(err.Error())
		// TODO: manage error
	}
}

func Init() {
	cfgFile := getAbs("./settings/settings.ini")

	cfg := new(ini.File)
	cfg.BlockMode = false
	cfg, err := ini.Load(cfgFile)
	if err != nil {
		panic(err)
	}

	cfg.MapTo(&settingStruct)
	settingStruct.Log.File = filepath.Join(
		getAbs(settingStruct.Log.Path),
		time.Now().Format(settingStruct.Log.Format),
	)

	//map to global
	{
		Static = settingStruct.Static
		Server = settingStruct.Server
		Filesync = settingStruct.Filesync
		Template = settingStruct.Template
		DefaultVars = settingStruct.DefaultVars
		Admin = settingStruct.Admin
		Log = settingStruct.Log
	}

	FsCfgMgr = new(cfgMgr)
	FsCfgMgr.Init()

	go watch()
}

func fsGetData(log *logging.Logger, section *common.Section, cfg *ini.File) {
	var previous int
	var res common.JSONFile
	var db database.DB

	if section.Dataset-1 == 0 {
		previous = cfg.Section("dataset").Key(section.Grace).MustInt()
	} else {
		previous = section.Dataset - 1
	}

	db.Open(log, cfg)
	defer db.Close()

	for _, item := range []string{"directory", "file", "symlink"} {
		for res = range database.ListItems(log, &db, section, item) {
			switch item {
			case "directory":
				fsSaveData(log, cfg, section, res, false)
			case "symlink":
				fsSaveData(log, cfg, section, res, false)
			case "file":
				if database.ItemExist(log, &db, &res, section, previous) {
					fsSaveData(log, cfg, section, res, true)
				} else {
					fsSaveData(log, cfg, section, res, false)
				}
			}
		}
	}
}

func fileRestore(log *logging.Logger, cfg *ini.File, section *common.Section) {
	// Execute pre_command
	execCommand(log, cfg.Section(section.Name), "pre_command")

	// Restore!
	restore.FileRestore(log, section, cfg)

	// Execute post_command
	execCommand(log, cfg.Section(section.Name), "post_command")
}

func Backup(log *logging.Logger, cfg *ini.File, grace string, reload bool) {
	const POOL = 5
	var db database.DB
	var tx *sql.Tx
	var c = make(chan bool, POOL)
	var wg = new(sync.WaitGroup)

	var dataset, maxdatasets int
	var sections []*ini.Section

	sections = cfg.Sections()

	maxdatasets, _ = cfg.Section("dataset").Key(grace).Int()

	db.Open(log, cfg)
	defer db.Close()

	tx, _ = db.Conn.Begin()
	dataset = database.GetDataset(log, tx, grace)
	tx.Commit()

	if !reload {
		if nextds := dataset + 1; nextds > maxdatasets {
			dataset = 1
		} else {
			dataset = dataset + 1
		}
	}
	log.Info("Dataset processed: " + strconv.Itoa(dataset))

	wg.Add(len(sections) - len(SECT_RESERVED))
	for _, section := range sections {
		if !contains(SECT_RESERVED, section.Name()) {
			if section.Key("type").String() == "file" { // FIXME: useless?
				sect := common.Section{
					Name:       section.Name(),
					Grace:      grace,
					Dataset:    dataset,
					Compressed: section.Key("compress").MustBool(),
				}

				go fileBackup(log, &sect, cfg, c, wg)
				c <- true
			}
		}
	}
	wg.Wait() // Wait for all the children to die
	close(c)

	tx, _ = db.Conn.Begin()
	database.SetDataset(log, tx, dataset, grace)
	tx.Commit()
}

func handleServices(confIni *ini.File, p *proxy.IsolationProxy) {
	confSection, err := confIni.GetSection("services")
	check(err)
	for _, service := range confSection.Keys() {
		if !isRunningLocally(service.Name(), service.String(), p.Registry) {
			go func(service *ini.Key) {
				check(p.Handle(service.Name(), service.String()))
			}(service)
		} else {
			// If the service should be running locally on the same port, don't proxy it
			services.L.Warnf("Not handling %s on %s: should be running locally", service.Name(), service.String())
		}
	}
}

func (db *DB) retrieveCfgData(cfg *ini.File) {
	db.User = cfg.Section("database").Key("user").String()
	db.Password = cfg.Section("database").Key("password").String()
	db.Host = cfg.Section("database").Key("host").String()
	db.Port = cfg.Section("database").Key("port").String()
	db.Database = cfg.Section("database").Key("dbname").String()
}

func (d *serverConf) generateConnInfoOfUser(ii *ini.File, user string) error {
	u, err := d.AuthSys.UserInfo(user)
	if err != nil {
		return err
	}
	keyBytes, err := MarshalPublicKey(d.publicKey)
	if err != nil {
		return err
	}
	url := fmt.Sprintf("d5://%s:%[email protected]%s/%s=%s/%s", u.Name, u.Pass, d.Listen, d.ServerName, NameOfKey(d.publicKey), d.Cipher)
	sec, _ := ii.NewSection(CF_CREDENTIAL)
	sec.NewKey(CF_URL, url)
	sec.NewKey(CF_KEY, base64.StdEncoding.EncodeToString(keyBytes))
	sec.Comment = _COMMENTED_PAC_SECTION
	return nil
}

func Restore(log *logging.Logger, cfg *ini.File, grace string) {
	dataset := cfg.Section("general").Key("dataset").MustInt()

	for _, section := range cfg.Sections() {
		if !contains(SECT_RESERVED, section.Name()) {
			if section.Key("type").String() == "file" {
				sect := common.Section{
					Name:       section.Name(),
					Grace:      grace,
					Dataset:    dataset,
					Compressed: section.Key("compress").MustBool(),
				}
				fileRestore(log, cfg, &sect)
			}
		}
	}
}

// Loads the primary configuration file and maps it into a Config type.
func parseConfigINI(cfgPathAbs string) (*Config, error) {
	var err error
	var cfg *Config = new(Config)
	var iniCfg *ini.File

	// loading the INI file contents into local struct
	if iniCfg, err = ini.Load(cfgPathAbs); err != nil {
		log.Fatalln("[Config] Errors on parsing INI file:", err)
		return nil, err
	}

	// mapping configuration into local struct
	if err = iniCfg.MapTo(cfg); err != nil {
		log.Fatalln("[Config] Errors on mapping INI:", err)
		return nil, err
	}

	return cfg, nil
}

func FileRestore(log *logging.Logger, section *common.Section, cfg *ini.File) {
	var cmd common.JSONMessage
	var res common.JSONFile
	var db database.DB
	var err error

	db.Open(log, cfg)
	defer db.Close()

	cmd.Context = "file"
	cmd.Command.Name = "put"

	if cfg.Section(section.Name).Key("path").String() == "" {
		log.Debug("About to full restore")
		cmd.Command.ACL = cfg.Section(section.Name).Key("acl").MustBool()
		for _, item := range []string{"directory", "file", "symlink"} {
			for res = range database.ListItems(log, &db, section, item) {
				if cmd.Command.ACL {
					log.Debug("About to restore ACLs for " + res.Name)
					res.Acl, err = database.GetAcls(log, &db, res.Name, section)
					if err != nil {
						log.Error("ACLs extraction error for " + res.Name)
						log.Debug("error: " + err.Error())
					}
				}

				cmd.Command.Element = res
				put(log, section, cfg, &cmd)
			}
		}
	} else {
		log.Debug("About to restore path " + cfg.Section(section.Name).Key("path").String())

		cmd.Command.Element, err = database.GetItem(log, &db, cfg.Section(section.Name).Key("path").String(), section)
		if err != nil {
			log.Error("Error when putting data to section " + section.Name)
			log.Debug("error: " + err.Error())
		} else {
			cmd.Command.ACL = cfg.Section(section.Name).Key("acl").MustBool()
			put(log, section, cfg, &cmd)
		}
	}
}

func loadServiceRegistry(confIni *ini.File) proxy.LocalRegistry {
	reg := make(proxy.LocalRegistry)
	addService := func(name string, endpoints ...string) {
		for _, addr := range endpoints {
			endpoint := &proxy.Endpoint{
				Service: name,
				Host:    addr,
			}
			endpoint.TestActive()
			reg.Add(name, endpoint)
		}
	}

	confSection, err := confIni.GetSection("backends")
	check(err)
	for _, service := range confSection.Keys() {
		addService(service.Name(), service.Strings(",")...)
	}
	return reg
}

func put(log *logging.Logger, section *common.Section, cfg *ini.File, cmd *common.JSONMessage) {
	var conn net.Conn
	var err error

	conn, err = network.GetSocket(cfg.Section(section.Name))
	if err != nil {
		log.Error("Error when opening connection with section " + section.Name)
		log.Debug("error: " + err.Error())
		return
	}
	defer conn.Close()

	cmd.Send(conn)

	if cmd.Command.Element.Type == "file" {
		transfered := dataset.Path(cfg, section, false) + string(filepath.Separator) + cmd.Command.Element.Name
		if err := common.SendFile(transfered, conn); err != nil {
			log.Debug("Error when sending file: ", err.Error())
		}

	}
}

func Path(cfg *ini.File, section *common.Section, previous bool) string {
	var dataset int

	if previous {
		if section.Dataset == 1 {
			dataset = cfg.Section("dataset").Key(section.Grace).MustInt()
		} else {
			dataset = section.Dataset - 1
		}
	} else {
		dataset = section.Dataset
	}

	destination := strings.Join([]string{
		cfg.Section("general").Key("repository").String(),
		section.Grace,
		strconv.Itoa(dataset),
		section.Name,
	}, string(filepath.Separator))

	return destination
}