func phyElements(w http.ResponseWriter, r *http.Request) {
dest := ""
if r.FormValue("dest") == "" && len(utils.SplitPath(html.UnescapeString(r.FormValue("path")))) > 0 {
// go up one directory
dest = filepath.Dir(html.UnescapeString(r.FormValue("path")))
} else {
dest = filepath.Join(html.UnescapeString(r.FormValue("path")), html.UnescapeString(r.FormValue("dest")))
}
level := len(utils.SplitPath(dest))
var data []byte
var elements []element
if level == 0 {
elements = make([]element, len(repos))
for i, e := range repos {
elements[i] = element{e.Name, "DIR", "0", "0", true, dest}
}
} else if level > 0 {
fp := filepath.Join("repositories", utils.SplitPath(dest)[0], "origin")
if level > 1 {
for _, e := range utils.SplitPath(dest)[1:] {
fp = filepath.Join(fp, e)
}
}
infos, err := ioutil.ReadDir(fp)
if err != nil && !os.IsNotExist(err) {
log.Panic(err)
}
if err == nil {
elements = make([]element, len(infos))
for i, e := range infos {
ext := filepath.Ext(e.Name())
if e.IsDir() {
ext = "DIR"
}
elements[i] = element{e.Name(), ext, strconv.FormatInt(e.Size(), 10), e.ModTime().Format(types.TIMESTAMP_FMT), e.IsDir(), dest}
}
}
}
if len(elements) == 0 {
elements = []element{element{"", "DUMMY0", "0", "0", false, dest}}
}
data, err := json.Marshal(elements)
if err != nil {
log.Panic(err)
}
w.Write(data)
}
func restore(w http.ResponseWriter, r *http.Request) {
source := utils.SplitPath(html.UnescapeString(r.FormValue("source")))
element := html.UnescapeString(r.FormValue("element"))
target := utils.SplitPath(html.UnescapeString(r.FormValue("target")))
time := source[1]
sourcePath, err := filepath.EvalSymlinks(filepath.Join("repositories", source[0], "basepath"))
if err != nil {
log.Panic("Sourcepath: unable to find EvalSymlinks Path", err)
}
for _, e := range source[2:] {
sourcePath = filepath.Join(sourcePath, e)
}
sourcePath = filepath.Join(sourcePath, element)
targetPath, err := filepath.EvalSymlinks(filepath.Join("repositories", target[0], "origin"))
if err != nil {
log.Panic("Targetpath: unable to find EvalSymlinks Path", err)
}
for _, e := range target[1:] {
targetPath = filepath.Join(targetPath, e)
}
targetPath = filepath.Join(targetPath, element)
fmt.Println(sourcePath, targetPath, time)
output, error := wrapper.Restore(sourcePath, targetPath, time)
if error != nil {
log.Panic("unable to restore", sourcePath, target, time, error)
}
log.Println(string(output))
if permissions_ {
output, err = wrapper.Permissions(targetPath)
if err != nil {
log.Panic("while restoring:", err)
}
log.Println(string(output))
}
}
func rdiffElements(w http.ResponseWriter, r *http.Request) {
dest := ""
if r.FormValue("dest") == "" && len(utils.SplitPath(html.UnescapeString(r.FormValue("path")))) > 0 {
// we want to go up one directory
dest = filepath.Dir(html.UnescapeString(r.FormValue("path")))
} else {
dest = filepath.Join(html.UnescapeString(r.FormValue("path")), html.UnescapeString(r.FormValue("dest")))
}
level := len(utils.SplitPath(dest))
var data []byte
var elements []element
if level == 0 {
elements = make([]element, len(repos))
for i, e := range repos {
elements[i] = element{e.Name, "DIR", "0", "0", true, dest}
}
}
if level == 1 {
name := utils.SplitPath(dest)[0]
path := filepath.Join("repositories", name)
repo := utils.Repository{
filepath.Join(path, "basepath"),
filepath.Join(path, "directorystructure"),
filepath.Join(path, "origin"),
name,
}
times, err := repo.TimeStamps()
if err != nil {
log.Panic(err)
}
elements = make([]element, len(times))
for i, e := range times {
u, err := utils.Unquote(e)
if err != nil {
log.Panic(err)
}
elements[i] = element{u, "DIR", "0", "0", true, dest}
}
}
if level > 1 {
name := utils.SplitPath(dest)[0]
path := filepath.Join("repositories", name)
repo := utils.Repository{
filepath.Join(path, "basepath"),
filepath.Join(path, "directorystructure"),
filepath.Join(path, "origin"),
name,
}
var p string
if len(utils.SplitPath(dest)) == 2 {
p = ""
} else {
for _, e := range utils.SplitPath(dest)[2:] {
p = filepath.Join(p, e)
}
}
time_, err := utils.Unquote(utils.SplitPath(dest)[1])
if err != nil {
log.Panic(err)
}
timepoint, err := time.Parse(types.TIMESTAMP_FMT, time_)
if err != nil {
log.Panic(err)
}
dirs, err := incs.Directories(&repo, p, timepoint)
if err != nil {
log.Panic(err)
}
files, err := incs.Files(&repo, p, timepoint)
if err != nil {
log.Panic(err)
}
elements = make([]element, len(dirs)+len(files))
for i, e := range dirs {
elements[i] = element{e, "DIR", "0", "0", true, dest}
}
for i, e := range files {
elements[i+len(dirs)] = element{e, filepath.Ext(e), "0", "0", false, dest}
}
if len(elements) == 0 {
elements = []element{element{"", "DUMMY0", "0", "0", false, dest}}
}
}
data, err := json.Marshal(elements)
if err != nil {
log.Panic("unable to marshal table rows", err)
}
w.Write(data)
}