func showHandler(backend appchilada.Backend) func(http.ResponseWriter, *http.Request) {
getTemplate := getTemplateFunc("resources/show.html")
return func(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
name := r.URL.Path[len("/show/"):]
var start, end int64
if startVal := r.Form.Get("start"); startVal != "" {
start, _ = strconv.Atoi64(startVal)
} else {
// Default to last 24 hours
start = time.Seconds() - 86400
}
if endVal := r.Form.Get("end"); endVal != "" {
end, _ = strconv.Atoi64(endVal)
} else {
// Default to now
end = time.Seconds()
}
results, err := backend.Read(name, appchilada.Interval{start, end})
if err != nil {
// TODO Output error in response
log.Printf("Error getting results for %s: %v", name, err)
return
}
if err := getTemplate().Execute(w, results); err != nil {
log.Printf("Error executing template: %v", err)
}
}
}
func tfquery(req *http.Request) {
query := strings.Split(req.URL.RawQuery, "&", 0)
//fmt.Printf("path : %v\n", path)
//fmt.Printf("query: %v\n", query)
for i := 0; i < len(query); i++ {
nv := strings.Split(query[i], "=", 2)
if len(nv) == 2 {
switch nv[0] {
case "b":
begindate = nv[1]
case "e":
enddate = nv[1]
case "t":
title, _ = http.URLUnescape(nv[1])
case "c":
tcount, _ = strconv.Atoi(nv[1])
case "l":
lineheight, _ = strconv.Atoi64(nv[1])
case "p":
picwidth, _ = strconv.Atoi64(nv[1])
case "s":
spacing, _ = strconv.Atoi(nv[1])
case "m":
markerwidth, _ = strconv.Atoi64(nv[1])
}
}
//fmt.Printf("nv: %v\n", nv)
//showparams("Using ")
}
}
func checkJoinByteRanges(t *testing.T, inputRangesStr string, expectedRangeStr string) {
inputRanges := make([]ByteRange, 0, 10)
appendRange := func(offset int64, length int64) {
inputRanges = inputRanges[0 : len(inputRanges)+1]
inputRanges[len(inputRanges)-1] = ByteRange{offset, length}
}
for _, rangeStr := range strings.Split(inputRangesStr, ",", -1) {
//print("Got \"", rangeStr, "\" from input \"", inputRangesStr, "\"\n")
if len(rangeStr) == 0 {
// Uh, this is stupid.
continue
}
parts := strings.Split(rangeStr, ":", 2)
offset, _ := strconv.Atoi64(parts[0])
length, _ := strconv.Atoi64(parts[1])
appendRange(offset, length)
}
actualRange := joinByteRanges(inputRanges)
actualRangeStr := actualRange.String()
if actualRangeStr != expectedRangeStr {
t.Errorf("Ranges \"%s\": expected compression to %s, actual %s\n", inputRangesStr, expectedRangeStr, actualRangeStr)
return
}
}
func rateLimitStats(resp *http.Response) {
if resp == nil {
return
}
curr := time.Seconds()
reset, _ := strconv.Atoi64(resp.GetHeader("X-RateLimit-Reset"))
remaining, _ := strconv.Atoi64(resp.GetHeader("X-RateLimit-Remaining"))
if remaining < 1 && reset-curr > 0 {
log.Printf("Twitter API limits exceeded. Sleeping for %d seconds.\n", reset-curr)
time.Sleep((reset - curr) * 1e9)
}
}
// parseRange parses a Range header string as per RFC 2616.
func parseRange(s string, size int64) ([]httpRange, os.Error) {
if s == "" {
return nil, nil // header not present
}
const b = "bytes="
if !strings.HasPrefix(s, b) {
return nil, os.NewError("invalid range")
}
var ranges []httpRange
for _, ra := range strings.Split(s[len(b):], ",", -1) {
i := strings.Index(ra, "-")
if i < 0 {
return nil, os.NewError("invalid range")
}
start, end := ra[:i], ra[i+1:]
var r httpRange
if start == "" {
// If no start is specified, end specifies the
// range start relative to the end of the file.
i, err := strconv.Atoi64(end)
if err != nil {
return nil, os.NewError("invalid range")
}
if i > size {
i = size
}
r.start = size - i
r.length = size - r.start
} else {
i, err := strconv.Atoi64(start)
if err != nil || i > size || i < 0 {
return nil, os.NewError("invalid range")
}
r.start = i
if end == "" {
// If no end is specified, range extends to end of the file.
r.length = size - r.start
} else {
i, err := strconv.Atoi64(end)
if err != nil || r.start > i {
return nil, os.NewError("invalid range")
}
if i >= size {
i = size - 1
}
r.length = i - r.start + 1
}
}
ranges = append(ranges, r)
}
return ranges, nil
}
func FileHandler(store fs.LocalStore) http.HandlerFunc {
return func(resp http.ResponseWriter, req *http.Request) {
setBinaryResp(resp)
strong, hasStrong := mux.Vars(req)["strong"]
if !hasStrong {
writeResponseError(resp, http.StatusInternalServerError,
"Missing parameter: strong")
return
}
offsetStr, hasOffset := mux.Vars(req)["offset"]
if !hasOffset {
writeResponseError(resp, http.StatusInternalServerError,
"Missing parameter: offset")
return
}
offset, err := strconv.Atoi64(offsetStr)
if err != nil {
writeResponseError(resp, http.StatusInternalServerError,
fmt.Sprintf("Invalid format for length: %s", offsetStr))
return
}
lengthStr, hasLength := mux.Vars(req)["length"]
if !hasLength {
writeResponseError(resp, http.StatusInternalServerError,
"Missing parameter: length")
return
}
length, err := strconv.Atoi64(lengthStr)
if err != nil {
writeResponseError(resp, http.StatusInternalServerError,
fmt.Sprintf("Invalid format for length: %s", lengthStr))
return
}
buffer := bytes.NewBuffer([]byte{})
n, err := store.ReadInto(strong, offset, length, buffer)
if err != nil {
writeResponseError(resp, http.StatusInternalServerError, err.String())
return
}
if n < length {
writeResponseError(resp, http.StatusInternalServerError, io.ErrShortWrite.String())
}
resp.Write(buffer.Bytes())
}
}
func PointFromString(ptstr string) (*Point, os.Error) {
re := regexp.MustCompile("(-?[0-9]+),(-?[0-9]+),(-?[0-9]+),(-?[0-9]+)")
matches := re.FindStringSubmatch(ptstr)
if len(matches) < 5 {
return nil, os.NewError("invalid pointstring")
}
x, ex := strconv.Atoi64(matches[1])
x2, ex2 := strconv.Atoi64(matches[2])
y, ey := strconv.Atoi64(matches[3])
y2, ey2 := strconv.Atoi64(matches[4])
if ex != nil || ex2 != nil || ey != nil || ey2 != nil {
return &Point{new(Integer), new(Integer)}, os.NewError("point.FromString: failed to parse coordinates.")
}
return &Point{&Integer{x, x2}, &Integer{y, y2}}, nil
}
// verifyHmac verifies that a message authentication code (MAC) is valid.
//
// The provided source bytes must be in the form "value|timestamp|message".
func verifyHmac(h hash.Hash, key string, value []byte, timestamp, minAge,
maxAge int64) ([]byte, error) {
parts := bytes.SplitN(value, []byte("|"), 3)
if len(parts) != 3 {
return nil, ErrAuthentication
}
rv := parts[0]
tst, _ := strconv.Atoi64(string(parts[1]))
msg := parts[2]
if tst == 0 {
return nil, ErrBadTimestamp
}
if minAge != 0 && tst > timestamp-minAge {
return nil, ErrNewTimestamp
}
if maxAge != 0 && tst < timestamp-maxAge {
return nil, ErrOldTimestamp
}
// There are several other operations being done by the Encoder so not
// sure if ConstantTimeCompare() is worth at all.
msg2 := mac(h, key, rv, tst)
if len(msg) != len(msg2) || subtle.ConstantTimeCompare(msg, msg2) != 1 {
return nil, ErrAuthentication
}
return rv, nil
}
// Given a tag string with the format specified in the package comment,
// parseFieldParameters will parse it into a fieldParameters structure,
// ignoring unknown parts of the string.
func parseFieldParameters(str string) (ret fieldParameters) {
for _, part := range strings.Split(str, ",", 0) {
switch {
case part == "optional":
ret.optional = true
case part == "explicit":
ret.explicit = true
if ret.tag == nil {
ret.tag = new(int)
*ret.tag = 0
}
case strings.HasPrefix(part, "default:"):
i, err := strconv.Atoi64(part[8:len(part)])
if err == nil {
ret.defaultValue = new(int64)
*ret.defaultValue = i
}
case strings.HasPrefix(part, "tag:"):
i, err := strconv.Atoi(part[4:len(part)])
if err == nil {
ret.tag = new(int)
*ret.tag = i
}
}
}
return
}
func parseIndexLine(l []byte) (*indexInfo, error) {
// fmt.Fprintf (os.Stderr, "Processing line:\n%s\n", l)
newIndexInfo := indexInfo{}
var err error
fields := bytes.Fields(l)
newIndexInfo.lemma = fields[LEMMA]
// newIndexInfo.pos, err = strconv.Atoui64(string(fields[POS]))
if len(fields[POS]) > 1 {
return nil, ERR_MSG(SYNTACTIC_CATEGORY_TOO_LONG)
}
newIndexInfo.pos = fields[POS][0]
ptr_cnt, err := strconv.Atoi(string(fields[PTR_CNT]))
if err != nil {
return nil, err
}
ptr_symbols := fields[SYMBOL : SYMBOL+ptr_cnt]
newIndexInfo.ptr_symbols = ptr_symbols
newIndexInfo.tagsense_cnt, err = strconv.Atoi(string(fields[TAGSENSE_CNT+ptr_cnt]))
if err != nil {
return nil, err
}
offsets_strs := fields[(SYNSET_OFFSET + ptr_cnt - 1):]
offsets := make([]int64, len(offsets_strs))
for i, offset := range offsets_strs {
offsets[i], err = strconv.Atoi64(string(offset))
if err != nil {
return nil, err
}
}
newIndexInfo.offsets = offsets
return &newIndexInfo, nil
}
func ParseCase(i int, line string) *Auction {
a := &Auction{Case: i}
tokens := strings.Fields(line)
for p, s := range tokens {
val, err := strconv.Atoi64(s)
if err != nil {
log.Panic(i, line, err)
}
switch p {
case 0:
a.N = val
case 1:
a.P1 = val
case 2:
a.W1 = val
case 3:
a.M = val
case 4:
a.K = val
case 5:
a.A = val
case 6:
a.B = val
case 7:
a.C = val
case 8:
a.D = val
}
}
if Debug {
log.Printf("%#v", *a)
}
return a
}
func (ctx *Context) GetSecureCookie(name string) (string, bool) {
cookie, ok := ctx.Request.Cookies[name]
if !ok {
return "", false
}
parts := strings.Split(cookie, "|", 3)
val := parts[0]
timestamp := parts[1]
sig := parts[2]
if getCookieSig([]byte(val), timestamp) != sig {
return "", false
}
ts, _ := strconv.Atoi64(timestamp)
if time.Seconds()-31*86400 > ts {
return "", false
}
buf := bytes.NewBufferString(val)
encoder := base64.NewDecoder(base64.StdEncoding, buf)
res, _ := ioutil.ReadAll(encoder)
return string(res), true
}
func decodeSecureCookie(value string) (user string, session string, err os.Error) {
parts := strings.Split(value, "|", 3)
if len(parts) != 3 {
err = os.NewError("Malformed cookie value")
return
}
val := parts[0]
timestamp := parts[1]
sig := parts[2]
// Check signature
if getCookieSig([]byte(val), timestamp) != sig {
return "", "", os.NewError("Signature error, cookie is invalid")
}
// Check time stamp
ts, _ := strconv.Atoi64(timestamp)
if ts+maxAge < time.UTC().Seconds() {
return "", "", os.NewError("Cookie is outdated")
}
buf := bytes.NewBufferString(val)
encoder := base64.NewDecoder(base64.StdEncoding, buf)
res, _ := ioutil.ReadAll(encoder)
str := string(res)
lst := strings.Split(str, "!", -1)
if len(lst) != 2 {
return "", "", os.NewError("Missing !")
}
return lst[0], lst[1], nil
}
func parseIndexLine(l []byte) *indexInfo {
// fmt.Fprintf (os.Stderr, "Processing line:\n%s\n", l)
newIndexInfo := indexInfo{}
var err os.Error
fields := bytes.Fields(l)
ptr_cnt, err := strconv.Atoi(string(fields[PTR_CNT]))
if err != nil {
fmt.Fprintf(os.Stderr, "I had a problem trying to convert '%s' to int\n", fields[PTR_CNT])
os.Exit(1)
}
newIndexInfo.lemma = fields[LEMMA]
// newIndexInfo.pos, err = strconv.Atoui64(string(fields[POS]))
if len(fields[POS]) > 1 {
fmt.Fprintf(os.Stderr, "POS has to be 1 letter code ('n', 'v', 'a' or 'r') and I have %s\n", fields[POS])
os.Exit(1)
}
newIndexInfo.pos = fields[POS][0]
newIndexInfo.tagsense_cnt, err = strconv.Atoi(string(fields[TAGSENSE_CNT+ptr_cnt]))
if err != nil {
fmt.Fprintf(os.Stderr, "I had a problem trying to convert %s to int32\n", fields[TAGSENSE_CNT+ptr_cnt])
os.Exit(1)
}
offsets_strs := fields[(SYNSET_OFFSET + ptr_cnt):]
offsets := make([]int64, len(offsets_strs))
for i, offset := range offsets_strs {
offsets[i], err = strconv.Atoi64(string(offset))
if err != nil {
fmt.Fprintf(os.Stderr, "I had a problem trying to convert the offset %s to int63\n", offset)
os.Exit(1) // log.Fatal?
}
}
newIndexInfo.offsets = offsets
return &newIndexInfo
}
func (c *Client) FetchVia(b *blobref.BlobRef, v []*blobref.BlobRef) (blobref.ReadSeekCloser, int64, os.Error) {
url := fmt.Sprintf("%s/camli/%s", c.server, b)
if len(v) > 0 {
buf := bytes.NewBufferString(url)
buf.WriteString("?via=")
for i, br := range v {
if i != 0 {
buf.WriteString(",")
}
buf.WriteString(br.String())
}
url = buf.String()
}
req := http.NewGetRequest(url)
if c.HasAuthCredentials() {
req.Header["Authorization"] = c.authHeader()
}
resp, err := req.Send()
if err != nil {
return nil, 0, err
}
var size int64
if s := resp.GetHeader("Content-Length"); s != "" {
size, _ = strconv.Atoi64(s)
}
return nopSeeker{resp.Body}, size, nil
}
func (self FitsHeaderItem) AsInt() int64 {
value, err := strconv.Atoi64(self.first_token())
if err != nil {
return -1
}
return value
}
// Given a tag string with the format specified in the package comment,
// parseFieldParameters will parse it into a fieldParameters structure,
// ignoring unknown parts of the string.
func parseFieldParameters(str string) (ret fieldParameters) {
for _, part := range strings.Split(str, ",", -1) {
switch {
case part == "optional":
ret.optional = true
case part == "explicit":
ret.explicit = true
if ret.tag == nil {
ret.tag = new(int)
*ret.tag = 0
}
case part == "ia5":
ret.stringType = tagIA5String
case part == "printable":
ret.stringType = tagPrintableString
case strings.HasPrefix(part, "default:"):
i, err := strconv.Atoi64(part[8:])
if err == nil {
ret.defaultValue = new(int64)
*ret.defaultValue = i
}
case strings.HasPrefix(part, "tag:"):
i, err := strconv.Atoi(part[4:])
if err == nil {
ret.tag = new(int)
*ret.tag = i
}
case part == "set":
ret.set = true
}
}
return
}
// Get node value as int64
func (this *Node) I64(namespace, name string) int64 {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
n, _ := strconv.Atoi64(node.Value)
return n
}
return 0
}
// Get attribute value as int64
func (this *Node) Ai64(namespace, name string) int64 {
if s := this.As(namespace, name); s != "" {
n, _ := strconv.Atoi64(s)
return n
}
return 0
}
func decode(mutation string) (path, v string, rev int64, keep bool, err error) {
cm := strings.SplitN(mutation, ":", 2)
if len(cm) != 2 {
err = ErrBadMutation
return
}
rev, err = strconv.Atoi64(cm[0])
if err != nil {
return
}
kv := strings.SplitN(cm[1], "=", 2)
if err = checkPath(kv[0]); err != nil {
return
}
switch len(kv) {
case 1:
return kv[0], "", rev, false, nil
case 2:
return kv[0], kv[1], rev, true, nil
}
panic("unreachable")
}
func (ctx *Context) GetSecureCookie(name string) (string, bool) {
for _, cookie := range ctx.Request.Cookie {
if cookie.Name != name {
continue
}
parts := strings.SplitN(cookie.Value, "|", 3)
val := parts[0]
timestamp := parts[1]
sig := parts[2]
if getCookieSig(ctx.Server.Config.CookieSecret, []byte(val), timestamp) != sig {
return "", false
}
ts, _ := strconv.Atoi64(timestamp)
if time.Seconds()-31*86400 > ts {
return "", false
}
buf := bytes.NewBufferString(val)
encoder := base64.NewDecoder(base64.StdEncoding, buf)
res, _ := ioutil.ReadAll(encoder)
return string(res), true
}
return "", false
}
func send(req *http.Request) (resp *http.Response, err os.Error) {
addr := req.URL.Host
if !hasPort(addr) {
addr += ":http"
}
conn, err := net.Dial("tcp", "", addr)
if err != nil {
return nil, err
}
err = req.Write(conn)
if err != nil {
conn.Close()
return nil, err
}
reader := bufio.NewReader(conn)
resp, err = http.ReadResponse(reader, "GET")
if err != nil {
conn.Close()
return nil, err
}
r := io.Reader(reader)
if v := resp.GetHeader("Content-Length"); v != "" {
n, err := strconv.Atoi64(v)
if err != nil {
// return nil, &badStringError{"invalid Content-Length", v}
}
r = io.LimitReader(r, n)
}
resp.Body = readClose{r, conn}
return
}
func searchsite(c *appengine.Context, referer string) int64 {
hash := "ref:" + referer
item, err := memcache.Get(*c, hash)
if err != nil {
q := datastore.NewQuery("MySite").Filter("url", referer)
log.Print(q)
/* t := q.Run(*c)
/* var x MySite
key, err := t.Next(&x)
if err == datastore.Done {
//Not found
mysite := MySite {
url: referer,
created: datastore.SecondsToTime(time.Seconds()),
views : 1,
last_access: datastore.SecondsToTime(time.Seconds()),
}
key, _ := datastore.Put(*c, datastore.NewIncompleteKey("MySite"), &mysite)
return key.IntID()
}
return key.IntID()
*/
return 0
}
r, _ := strconv.Atoi64(string(item.Value))
return r
}
// ParseTime parses the time interval from s, and returns it
// as nanoseconds, if it is representable in seconds (with
// isNanoSeconds true), or sample count (with isNanoSeconds false)
// if not.
func ParseTime(s string) (t Time, err os.Error) {
endi := strings.LastIndexFunc(s, isDigit) + 1
if endi == 0 {
return Time{}, os.NewError("invalid number")
}
number, suffix := s[0:endi], s[endi:]
var mult int64
switch suffix {
case "s", "":
mult = 1e9
case "ms":
mult = 1e6
case "us":
mult = 1e3
case "ns":
mult = 1
case "x": // samples
mult = 1
}
// use exact arithmetic if we can
d, err := strconv.Atoi64(number)
if err != nil {
f, err := strconv.Atof64(number)
if err != nil {
return Time{}, err
}
d = int64(f * float64(mult))
} else {
d *= mult
}
return Time{d, suffix != "x"}, nil
}
func mustAtoi64(arg string) int64 {
n, err := strconv.Atoi64(arg)
if err != nil {
bail(err)
}
return n
}
func Import(uid, nick, user, host, ip, hops, ts, name string) os.Error {
userMutex.Lock()
defer userMutex.Unlock()
if _, ok := userMap[uid]; ok {
return os.NewError("UID collision")
}
lownick := parser.ToLower(nick)
if _, ok := userNicks[lownick]; ok {
return os.NewError("NICK collision")
}
its, _ := strconv.Atoi64(ts)
u := &User{
mutex: new(sync.RWMutex),
ts: its,
id: uid,
user: user,
nick: nick,
name: name,
utyp: RegisteredAsUser,
}
userMap[uid] = u
userNicks[lownick] = uid
return nil
}
func (myDHTServer *DHTServerStruct) processNewMessageLog() int {
//
// LOCAL
//
hid := myDHTServer.getHighestIDForNodeFromDHT(G_nodeID)
// myDHTServer.logger.Logf(LMAX, "Highest ID for Node %s is %d", G_nodeID, hid)
// Query newMessageLog
sql := fmt.Sprintf("SELECT id,sha1,mailbox,size FROM newMessageLog WHERE id > %d order by id LIMIT 100", hid)
// myDHTServer.logger.Logf(LMAX, "processNewMessageLog SQL: %s", sql)
G_nmlDBLock.Lock()
stmt, sqlerr := myDHTServer.nml.Prepare(sql)
defer stmt.Finalize()
defer G_nmlDBLock.Unlock()
if sqlerr != nil {
myDHTServer.logger.Logf(LMIN, "Unexpected error using DB (%s): %s", sql, sqlerr)
return 0
}
// Process results
count := 0
var id int
var sha1 string
var mailbox string
var size int
stmt.Exec()
for stmt.Next() {
err := stmt.Scan(&id, &sha1, &mailbox, &size)
if err != nil {
myDHTServer.logger.Logf(LMIN, "Unexpected error using DB: %s", err)
break
}
sql := fmt.Sprintf("INSERT INTO DHT (id, sha1, mailbox, cached, size, orignodeid) VALUES (%d, '%s', '%s', NULL, %d, %s)", id, sha1, mailbox, size, G_nodeID)
myDHTServer.logger.Logf(LMAX, "processNewMessageLog SQL: %s", sql)
G_dhtDBLock.Lock()
execerr := myDHTServer.dht.Exec(sql)
G_dhtDBLock.Unlock()
if execerr != nil {
myDHTServer.logger.Logf(LMIN, "processNewMessageLog - Unexpected error using DB (%s): %s", sql, execerr)
}
// Update the counters
// This is bad converting from string to int all the time
inode, inerr := strconv.Atoi64(G_nodeID)
if inerr != nil {
myDHTServer.logger.Log(LMIN, "Unexpected Atoi conversion")
return 0
}
setCounter(NEWMESSAGECOUNTERFILE, inode, uint64(id))
count += 1
}
return count
}
func AsInt16(v interface{}) (int16, os.Error) {
switch value := v.(type) {
default:
return 0, os.NewError(fmt.Sprintf("unexpected type: %T", value))
case int:
return int16(value), nil
case int8:
return int16(value), nil
case int16:
return value, nil
case int32:
return int16(value), nil
case int64:
return int16(value), nil
case uint:
return int16(value), nil
case uint8:
return int16(value), nil
case uint16:
return int16(value), nil
case uint32:
return int16(value), nil
case uint64:
return int16(value), nil
case float32:
return int16(value), nil
case float64:
return int16(value), nil
case string:
value64, err := strconv.Atoi64(value)
return int16(value64), err
}
panic(fmt.Sprintf("unsupported type: %s", reflect.ValueOf(v).Type().Name()))
}
// Scan parses the values of the current result row (set using Result.Next)
// into the given arguments.
func (r *Result) Scan(args ...interface{}) os.Error {
if len(args) != r.ncols {
return os.NewError(fmt.Sprintf("incorrect argument count for Result.Scan: have %d want %d", len(args), r.ncols))
}
for i, v := range args {
if int(C.PQgetisnull(r.res, C.int(r.currRow), C.int(i))) == 1 {
continue
}
val := C.GoString(C.PQgetvalue(r.res, C.int(r.currRow), C.int(i)))
switch v := v.(type) {
case *[]byte:
if !strings.HasPrefix(val, "\\x") {
return argErr(i, "[]byte", "invalid byte string format")
}
buf, err := hex.DecodeString(val[2:])
if err != nil {
return argErr(i, "[]byte", err.String())
}
*v = buf
case *string:
*v = val
case *bool:
*v = val == "t"
case *int:
x, err := strconv.Atoi(val)
if err != nil {
return argErr(i, "int", err.String())
}
*v = x
case *int64:
x, err := strconv.Atoi64(val)
if err != nil {
return argErr(i, "int64", err.String())
}
*v = x
case *float32:
x, err := strconv.Atof32(val)
if err != nil {
return argErr(i, "float32", err.String())
}
*v = x
case *float64:
x, err := strconv.Atof64(val)
if err != nil {
return argErr(i, "float64", err.String())
}
*v = x
case *time.Time:
x, _, err := ParseTimestamp(val)
if err != nil {
return argErr(i, "time.Time", err.String())
}
*v = *x
default:
return os.NewError("unsupported type in Scan: " + reflect.TypeOf(v).String())
}
}
return nil
}
func tch_handleComment(session *BlogSession, items []string) string {
if len(items) < 4 {
return "syntax: comment <post_id> <your_nick> <your many words of comment>\n"
}
post_id, _ := strconv.Atoi64(items[1])
nick := items[2]
content := strings.Join(items[3:], " ")
comment := PostComment{
Content: content,
Author: nick,
Timestamp: time.Seconds(),
PostId: post_id,
}
db := DBGet()
defer db.Close()
i, err := db.StoreComment(&comment)
if err != nil {
return "error: " + err.String() + "\n"
}
s := fmt.Sprintf("commented post %d. your comment's id: %d\n", post_id, i)
return s
}