gogs/cmd/serve.go

// Copyright 2013 gopm authors.
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.

package cmd

// import (
// 	"errors"
// 	"fmt"
// 	"github.com/Unknwon/com"
// 	"github.com/gpmgo/gopm/doc"
// 	"github.com/syndtr/goleveldb/leveldb"
// 	"github.com/syndtr/goleveldb/leveldb/opt"
// 	"io/ioutil"
// 	"net/http"
// 	"net/url"
// 	"os"
// 	"os/exec"
// 	"path/filepath"
// 	"strconv"
// 	"strings"
// 	"time"
// )

// var (
// 	dbDir = "~/.gopm/db"
// )

// const (
// 	STOP = iota
// 	LOCALRUN
// 	RUNNING
// )

// var CmdServe = &Command{
// 	UsageLine: "serve [:port]",
// 	Short:     "serve for package search",
// 	Long: `
// 	serve provide a web service to search packages, download packages

// The serve flags are:

// 	-l
// 		only service for localhost ip
// `,
// }

// func init() {
// 	CmdServe.Run = runServe
// 	CmdServe.Flags = map[string]bool{
// 		"-l": false,
// 	}
// }

// func printServePrompt(flag string) {
// 	switch flag {
// 	case "-l":
// 		com.ColorLog("[INFO] You enabled start a service only localhost.\n")
// 	}
// }

// // Not implemented
// func autoPort() string {
// 	return "8991"
// }

// func exePath() (string, error) {
// 	file, err := exec.LookPath(os.Args[0])
// 	if err != nil {
// 		return "", err
// 	}

// 	return filepath.Abs(file)
// }

// // search packages
// func runServe(cmd *Command, args []string) {
// 	// Check flags.
// 	num := checkFlags(cmd.Flags, args, printServePrompt)
// 	if num == -1 {
// 		return
// 	}
// 	args = args[num:]

// 	var listen string
// 	var port string
// 	if cmd.Flags["-l"] {
// 		listen += "127.0.0.1"
// 		port = autoPort()
// 	} else {
// 		listen += "0.0.0.0"
// 		port = "8991"
// 	}

// 	// Check length of arguments.
// 	if len(args) >= 1 {
// 		port = args[0]
// 	}

// 	err := startService(listen, port)
// 	if err != nil {
// 		com.ColorLog("[ERRO] %v\n", err)
// 	}
// }

// func splitWord(word string, res *map[string]bool) {
// 	for i, _ := range word {
// 		for j, _ := range word[i:] {
// 			w := word[i : i+j+1]
// 			(*res)[w] = true
// 		}
// 	}
// 	return
// }

// func splitPkgName(pkgName string) (res map[string]bool) {
// 	//var src string
// 	ps := strings.Split(pkgName, "/")
// 	if len(ps) > 1 {
// 		ps = ps[1:]
// 	}

// 	res = make(map[string]bool)
// 	res[strings.Join(ps, "/")] = true
// 	for _, w := range ps {
// 		splitWord(w, &res)
// 	}
// 	return
// }

// func splitSynopsis(synopsis string) map[string]bool {
// 	res := make(map[string]bool)
// 	ss := strings.Fields(synopsis)
// 	for _, s := range ss {
// 		res[s] = true
// 	}
// 	return res
// }

// var (
// 	ro *opt.ReadOptions  = &opt.ReadOptions{}
// 	wo *opt.WriteOptions = &opt.WriteOptions{}
// )

// func dbGet(key string) (string, error) {
// 	v, err := db.Get([]byte(key), ro)
// 	return string(v), err
// }

// func dbPut(key string, value string) error {
// 	//fmt.Println("put ", key, ": ", value)
// 	return db.Put([]byte(key), []byte(value), wo)
// }

// func batchPut(batch *leveldb.Batch, key string, value string) error {
// 	//fmt.Println("put ", key, ": ", value)
// 	batch.Put([]byte(key), []byte(value))
// 	return nil
// }

// func getServeHost() string {
// 	return "localhost"
// }

// func getServePort() string {
// 	return "8991"
// }

// // for exernal of serve to add node to db
// func saveNode(nod *doc.Node) error {
// 	urlPath := fmt.Sprintf("http://%v:%v/add", getServeHost(), getServePort())
// 	resp, err := http.PostForm(urlPath,
// 		url.Values{"importPath": {nod.ImportPath},
// 			"synopsis":    {nod.Synopsis},
// 			"downloadURL": {nod.DownloadURL},
// 			"isGetDeps":   {strconv.FormatBool(nod.IsGetDeps)},
// 			"type":        {nod.Type},
// 			"value":       {nod.Value}})

// 	if err != nil {
// 		com.ColorLog("[ERRO] Fail to save node[ %s ]\n", err)
// 		return err
// 	}
// 	defer resp.Body.Close()

// 	if resp.StatusCode == 200 {
// 		return nil
// 	}
// 	return errors.New("save node failed with " + resp.Status)
// }

// // for inetrnal of serve to add node to db
// func addNode(nod *doc.Node) error {
// 	batch := new(leveldb.Batch)
// 	strLastId, err := dbGet("lastId")
// 	if err != nil {
// 		if err == leveldb.ErrNotFound {
// 			strLastId = "0"
// 			err = batchPut(batch, "lastId", strLastId)
// 		} else {
// 			return err
// 		}
// 	}
// 	if err != nil {
// 		return err
// 	}

// 	lastId, err := strconv.ParseInt(strLastId, 0, 64)
// 	if err != nil {
// 		return err
// 	}

// 	nodKey := fmt.Sprintf("index:%v", nod.ImportPath)

// 	id, err := dbGet(nodKey)
// 	if err != nil {
// 		if err == leveldb.ErrNotFound {
// 			id = fmt.Sprintf("%v", lastId+1)
// 			err = batchPut(batch, "lastId", id)
// 			if err == nil {
// 				err = batchPut(batch, nodKey, id)
// 			}
// 			if err == nil {
// 				err = batchPut(batch, "pkg:"+id, nod.ImportPath)
// 			}
// 			if err == nil {
// 				err = batchPut(batch, "desc:"+id, nod.Synopsis)
// 			}
// 			if err == nil {
// 				err = batchPut(batch, "down:"+id, nod.DownloadURL)
// 			}
// 			if err == nil {
// 				err = batchPut(batch, "deps:"+id, strconv.FormatBool(nod.IsGetDeps))
// 			}

// 			// save totals
// 			total, err := dbGet("total")
// 			if err != nil {
// 				if err == leveldb.ErrNotFound {
// 					total = "1"
// 				} else {
// 					return err
// 				}
// 			} else {
// 				totalInt, err := strconv.ParseInt(total, 0, 64)
// 				if err != nil {
// 					return err
// 				}
// 				totalInt = totalInt + 1
// 				total = fmt.Sprintf("%v", totalInt)
// 			}

// 			err = batchPut(batch, "total", total)
// 		} else {
// 			return err
// 		}
// 	}

// 	if err != nil {
// 		return err
// 	}

// 	// save vers
// 	vers, err := dbGet("ver:" + id)
// 	needSplit := (err == leveldb.ErrNotFound)
// 	if err != nil {
// 		if err != leveldb.ErrNotFound {
// 			return err
// 		}
// 	} else {
// 		return nil
// 	}

// 	if vers == "" {
// 		//fmt.Println(nod)
// 		vers = nod.VerString()
// 	} else {
// 		if !strings.Contains(vers, nod.VerString()) {
// 			vers = vers + "," + nod.VerString()
// 		} else {
// 			return nil
// 		}
// 	}

// 	err = batchPut(batch, "ver:"+id, vers)
// 	if err != nil {
// 		return err
// 	}

// 	if !needSplit {
// 		return nil
// 	}

// 	// indexing package name
// 	keys := splitPkgName(nod.ImportPath)
// 	for key, _ := range keys {
// 		err = batchPut(batch, fmt.Sprintf("key:%v:%v", strings.ToLower(key), id), "")
// 		if err != nil {
// 			return err
// 		}
// 	}

// 	if nod.Synopsis != "" {
// 		fields := splitSynopsis(nod.Synopsis)
// 		for field, _ := range fields {
// 			err = batchPut(batch, fmt.Sprintf("key:%v:%v", strings.ToLower(field), id), "")
// 			if err != nil {
// 				return err
// 			}
// 		}
// 	}

// 	return db.Write(batch, wo)
// }

// func rmPkg(nod *doc.Node) {

// }

// var db *leveldb.DB

// // service should be run
// func AutoRun() error {
// 	s, _, _ := runningStatus()
// 	if s == STOP {
// 		// current path
// 		curPath, err := os.Getwd()
// 		if err != nil {
// 			return err
// 		}

// 		attr := &os.ProcAttr{
// 			Dir: curPath,
// 			Env: os.Environ(),
// 			//Files: []*os.File{nil, nil, nil},
// 			Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
// 		}

// 		p, err := exePath()
// 		if err != nil {
// 			return err
// 		}

// 		//com.ColorLog("[INFO] now is starting search daemon ...\n")
// 		_, err = os.StartProcess(p, []string{"gopm", "serve", "-l"}, attr)
// 		if err != nil {
// 			return err
// 		}
// 		time.Sleep(time.Second)
// 	}
// 	return nil
// }

// func runningStatus() (int, int, int) {
// 	pFile, err := getPidPath()
// 	if err != nil {
// 		return STOP, 0, 0
// 	}

// 	contentByte, err := ioutil.ReadFile(pFile)
// 	if err != nil {
// 		return STOP, 0, 0
// 	}
// 	content := string(contentByte)
// 	if len(content) < 0 || !strings.Contains(content, ",") {
// 		return STOP, 0, 0
// 	}
// 	cs := strings.Split(string(content), ",")
// 	if len(cs) != 3 {
// 		return STOP, 0, 0
// 	}
// 	status, err := strconv.Atoi(cs[0])
// 	if err != nil {
// 		return STOP, 0, 0
// 	}
// 	if status < STOP || status > RUNNING {
// 		return STOP, 0, 0
// 	}
// 	pid, err := strconv.Atoi(cs[1])
// 	if err != nil {
// 		return STOP, 0, 0
// 	}

// 	_, err = os.FindProcess(pid)
// 	if err != nil {
// 		return STOP, 0, 0
// 	}

// 	port, err := strconv.Atoi(cs[2])
// 	if err != nil {
// 		return STOP, 0, 0
// 	}

// 	return status, pid, port
// }

// func getPidPath() (string, error) {
// 	homeDir, err := com.HomeDir()
// 	if err != nil {
// 		return "", err
// 	}

// 	pFile := strings.Replace("~/.gopm/var/", "~", homeDir, -1)
// 	os.MkdirAll(pFile, os.ModePerm)
// 	return pFile + "pid", nil
// }

// func startService(listen, port string) error {
// 	homeDir, err := com.HomeDir()
// 	if err != nil {
// 		return err
// 	}

// 	pFile, err := getPidPath()
// 	if err != nil {
// 		return err
// 	}

// 	f, err := os.OpenFile(pFile, os.O_RDWR|os.O_CREATE, 0700)
// 	if err != nil {
// 		return err
// 	}
// 	defer f.Close()
// 	_, err = f.WriteString(fmt.Sprintf("%v,%v,%v", RUNNING, os.Getpid(), port))
// 	if err != nil {
// 		return err
// 	}

// 	dbDir = strings.Replace(dbDir, "~", homeDir, -1)

// 	db, err = leveldb.OpenFile(dbDir, nil)
// 	if err != nil {
// 		return err
// 	}
// 	defer db.Close()

// 	// these handlers should only access by localhost
// 	http.HandleFunc("/add", addHandler)
// 	http.HandleFunc("/rm", rmHandler)

// 	// these handlers can be accessed according listen's ip
// 	http.HandleFunc("/search", searchHandler)
// 	http.HandleFunc("/searche", searcheHandler)
// 	http.ListenAndServe(listen+":"+port, nil)
// 	return nil
// }

// func searchHandler(w http.ResponseWriter, r *http.Request) {
// 	r.ParseForm()
// 	ids := make(map[string]bool)
// 	for key, _ := range r.Form {
// 		iter := db.NewIterator(ro)
// 		rkey := fmt.Sprintf("key:%v:", strings.ToLower(key))
// 		if iter.Seek([]byte(rkey)) {
// 			k := iter.Key()
// 			if !strings.HasPrefix(string(k), rkey) {
// 				break
// 			} else {
// 				ids[string(k)] = true
// 			}
// 		}
// 		for iter.Next() {
// 			k := iter.Key()
// 			if !strings.HasPrefix(string(k), rkey) {
// 				break
// 			}
// 			ids[string(k)] = true
// 		}
// 	}

// 	pkgs := make([]string, 0)

// 	for id, _ := range ids {
// 		idkeys := strings.SplitN(id, ":", -1)
// 		rId := idkeys[len(idkeys)-1]
// 		//fmt.Println(rId)
// 		pkg, err := dbGet(fmt.Sprintf("pkg:%v", rId))
// 		if err != nil {
// 			com.ColorLog(err.Error())
// 			continue
// 		}
// 		desc, err := dbGet(fmt.Sprintf("desc:%v", rId))
// 		if err != nil {
// 			com.ColorLog(err.Error())
// 			continue
// 		}
// 		pkgs = append(pkgs, fmt.Sprintf(`{"pkg":"%v", "desc":"%v"}`, pkg, desc))
// 	}

// 	w.Write([]byte("[" + strings.Join(pkgs, ", ") + "]"))
// }

// func searcheHandler(w http.ResponseWriter, r *http.Request) {
// 	//if r.Method == "POST" {
// 	r.ParseForm()
// 	pkgs := make([]string, 0)
// 	for key, _ := range r.Form {
// 		rId, err := dbGet("index:" + key)
// 		if err != nil {
// 			com.ColorLog(err.Error())
// 			continue
// 		}

// 		desc, err := dbGet(fmt.Sprintf("desc:%v", rId))
// 		if err != nil {
// 			com.ColorLog(err.Error())
// 			continue
// 		}

// 		pkgs = append(pkgs, fmt.Sprintf(`{"pkg":"%v", "desc":"%v"}`, key, desc))
// 	}

// 	w.Write([]byte("[" + strings.Join(pkgs, ", ") + "]"))
// 	//}
// }

// func addHandler(w http.ResponseWriter, r *http.Request) {
// 	//if r.Method == "POST" {
// 	r.ParseForm()

// 	nod := new(doc.Node)
// 	nod.ImportPath = r.FormValue("importPath")
// 	nod.Synopsis = r.FormValue("synopsis")
// 	nod.DownloadURL = r.FormValue("downloadURL")
// 	isGetDeps, err := strconv.ParseBool(r.FormValue("isGetDeps"))
// 	if err != nil {
// 		com.ColorLog("[ERRO] SEVER: Cannot get deps")
// 	}
// 	nod.IsGetDeps = isGetDeps
// 	nod.Type = r.FormValue("type")
// 	nod.Value = r.FormValue("value")

// 	err = addNode(nod)
// 	if err != nil {
// 		com.ColorLog("[ERRO] SEVER: Cannot add node[ %s ]\n", err)
// 	}
// 	//}
// }

// func rmHandler(w http.ResponseWriter, r *http.Request) {

// }