Exemple #1
0
func (t *TmpFiles) GetByField(field string) (f *temp.File, err error) {
	f = t.fields[field]
	if f == nil {
		aelog.Debugf("Find file by field: %s", field)
		url := t.r.FormValue(field + "_url")
		f = temp.NewFile(t.tmpDir)
		if url != "" {
			aelog.Debugf("Url found[%s]: %s", field, url)
			f.OrigName = filepath.Base(url)
			if err = f.LoadFromUrl(url); err != nil {
				return
			}
		} else {
			mf, mh, e := t.r.FormFile(field)
			if e != nil {
				err = e
				return
			}
			if err = f.LoadFromForm(mf); err != nil {
				return
			}
			f.OrigName = mh.Filename
		}
		t.fields[field] = f
	}
	return
}
Exemple #2
0
func (u *Uploader) TryRequest(r *http.Request, w http.ResponseWriter) (status bool, err error, errCode int) {
	if !u.conf.UploaderEnable {
		return
	}
	token := r.URL.Query().Get(u.conf.UploaderParamName)
	if token == "" {
		return
	}

	aelog.Debugf("Uploader: token found: %s\n", token)

	status = true

	write := func(token string, params interface{}, err error) {
		var resp *http.Response
		if err != nil {
			resp, err = u.ctrl.SetStatusErr(token, err)
		} else {
			resp, err = u.ctrl.SetStatus(token, params)
		}
		if err != nil {
			errCode = 500
			return
		}
		w.Header().Set("Content-Type", "application/x-javascript")
		w.WriteHeader(resp.StatusCode)
		io.Copy(w, resp.Body)
		err = nil
	}

	files, err := u.ctrl.GetParams(token)
	if err != nil {
		if err == ErrTokenNotFound {
			aelog.Debugln("Uploader: ctrl return not found")
			errCode = 404
		} else {
			errCode = 500
			aelog.Debugf("Uploader: ctrl return error: %v\n", err)
			write(token, nil, err)
		}
		return
	}

	err = files.Upload(u.conf, u.stor, r, w)

	if err != nil {
		aelog.Debugf("Uploader: files.Upload has err: %v\n", err)
		errCode = 500
		write(token, nil, err)
		return
	}
	write(token, files, nil)
	aelog.Debugln("Uploader: files.Upload done")
	return
}
Exemple #3
0
func (c *Container) Dump() (err error) {
	c.m.Lock()
	defer c.m.Unlock()

	if !c.ch {
		return
	}

	st := time.Now()
	var i int64

	c.FDump = make(map[int64]*File, c.FileCount)
	c.HDump = make(map[int64]*Hole, c.holeIndex.Count)

	var last Space = c.last

	for last != nil && c.last != nil {
		if last.IsFree() {
			c.HDump[i] = last.(*Hole)
		} else {
			c.FDump[i] = last.(*File)
		}
		last = last.Prev()
		i++
	}

	pr := time.Since(st)

	n, err := dump.DumpTo(c.indexName(), c)
	aelog.Debugf("Dump container %d, writed %s for a %v (prep: %v)", c.Id, utils.HumanBytes(n), time.Since(st), pr)
	c.ch = false
	return
}
Exemple #4
0
func (s *Server) Download(name string, w http.ResponseWriter, r *http.Request) {
	_, ok := s.stor.Get(name)
	if ok {
		// File exists
		s.Err(409, r, w)
		return
	}
	url := s.downloadUrl(r)
	tf := temp.NewFile(s.conf.TmpDir)
	aelog.Debugf("Start download from %s\n", url)
	err := tf.LoadFromUrl(url)
	defer tf.Close()
	if err != nil {
		aelog.Infof("Can't download : %s, err: %v\n", url, err)
		s.Err(500, r, w)
		return
	}
	// again check for exists
	_, ok = s.stor.Get(name)
	if ok {
		s.Err(409, r, w)
		return
	}
	s.save(name, tf.Size, tf.File, r, w)
}
Exemple #5
0
func (fs *Files) Upload(conf *config.Config, stor *storage.Storage, r *http.Request, w http.ResponseWriter) (err error) {
	// make temp files object
	tmpfs := &TmpFiles{r: r, fields: make(map[string]*temp.File), result: make(map[string]*temp.File), tmpDir: conf.TmpDir}
	defer tmpfs.Close()

	// upload
	for _, f := range *fs {
		err = f.Upload(tmpfs)
		if err != nil {
			return
		}
	}

	result := tmpfs.Result()

	// add to storage and set stae
	for name, tf := range result {
		aelog.Debugf("Uploader add file: %s (%s, %s)", name, utils.HumanBytes(tf.Size), tf.MimeType)
		file, _ := stor.Add(name, tf.File, tf.Size)
		for _, f := range *fs {
			if f.Name == name {
				f.SetState(file)
			}
		}
	}

	return
}
Exemple #6
0
func (s *Storage) Open() (err error) {
	aelog.Debugf("Try open %s..", s.Conf.DataPath)
	dir, err := os.Open(s.Conf.DataPath)
	if err != nil {
		return
	}
	info, err := dir.Stat()
	if err != nil {
		return
	}
	if !info.IsDir() {
		return errors.New("Data path must be dir")
	}

	wg := &sync.WaitGroup{}
	files, err := dir.Readdir(-1)
	for _, file := range files {
		if filepath.Ext(file.Name()) == ".index" {
			wg.Add(1)
			go func(name string) {
				name = s.Conf.DataPath + name
				e := s.restoreContainer(name)
				if e != nil {
					err = e
				}
				wg.Done()
			}(file.Name())
		}
	}
	wg.Wait()

	if err != nil {
		return
	}

	if len(s.Containers) == 0 {
		aelog.Info("Create first container")
		if _, err = s.createContainer(); err != nil {
			return
		}
	}

	go func() {
		if s.Conf.DumpTime > 0 {
			for {
				time.Sleep(s.Conf.DumpTime)
				s.Dump()
			}
		}
	}()

	return
}
Exemple #7
0
func (u unZip) OnSave(file *storage.File, w http.ResponseWriter, r *http.Request, s *storage.Storage) (e error) {
	mode := u.needUnZip(r)
	if mode == UNZIP_NO {
		return
	}
	aelog.Debugf("UnZip: start unzip(%d) files to: %s (%s)", mode, file.Name, utils.HumanBytes(file.FSize))
	if mode == UNZIP_FORCE {
		s.DeleteChilds(file.Name)
	}

	filesCount, filesSize, err := u.unZipTo(file.Name, file, s)
	if err != nil {
		aelog.Debugf("UnZip: error: %v", err)
		w.Header().Add("X-Ae-Unzip-Error", err.Error())
		return
	}
	aelog.Debugf("UnZip: unziped: %s (%d files, %s files size)", file.Name, filesCount, utils.HumanBytes(filesSize))
	w.Header().Add("X-Ae-Unzip-Count", fmt.Sprint(filesCount))
	w.Header().Add("X-Ae-Unzip-Size", utils.HumanBytes(filesSize))
	return
}
Exemple #8
0
func StartRpcServer(s *storage.Storage) {
	r := &Storage{
		s: s,
	}
	rpc.Register(r)
	rpc.HandleHTTP()

	l, e := net.Listen("tcp", s.Conf.RpcAddr)
	if e != nil {
		panic("Rpc listen error:" + e.Error())
	}
	aelog.Debugf("Start rpc server on %s\n", s.Conf.RpcAddr)
	go http.Serve(l, nil)
}
Exemple #9
0
func (s *Storage) restoreContainer(path string) (err error) {
	aelog.Debugf("Restore container from %s..", path)
	container := &Container{}
	if err, _ = dump.LoadData(path, container); err != nil {
		return err
	}
	if container.Created {
		if err = container.Init(s); err != nil {
			return
		}
		s.m.Lock()
		if container.Id > s.LastContainerId {
			s.LastContainerId = container.Id
		}
		s.Containers[container.Id] = container
		s.m.Unlock()
		aelog.Debugf("Container %d restored. %d (%d) files (holes) found", container.Id, container.FileCount, container.holeIndex.Count)
		//container.holeIndex.Print()
		//container.Print()
	} else {
		return fmt.Errorf("Can't restore container from %s", path)
	}
	return
}