// ReadCheckpoint reads a checkpoint structure from the durable file dfile. func ReadCheckpoint(dfile string) (*Checkpoint, error) { // Fetch service info from durable fs f, err := durablefs.OpenFile(dfile) if err != nil { return nil, err } chk_, err := f.Read() if err != nil { return nil, err } if len(chk_) == 0 { return nil, circuit.NewError("no values in checkpoint durable file " + dfile) } chk, ok := chk_[0].(*Checkpoint) if !ok { return nil, circuit.NewError("unexpected checkpoint value (%#v) of type (%T) in durable file %s", chk_[0], chk_[0], dfile) } return chk, nil }
// RuntimeProfile exposes the Go runtime profiling framework of this worker func (s *Acid) RuntimeProfile(name string, debug int) ([]byte, error) { prof := pprof.Lookup(name) if prof == nil { return nil, circuit.NewError("no such profile") } var w bytes.Buffer if err := prof.WriteTo(&w, debug); err != nil { return nil, err } return w.Bytes(), nil }
func (s *Acid) CPUProfile(duration time.Duration) ([]byte, error) { if duration > time.Hour { return nil, circuit.NewError("cpu profile duration exceeds 1 hour") } var w bytes.Buffer if err := pprof.StartCPUProfile(&w); err != nil { return nil, err } log.Printf("cpu profiling for %d sec", duration/1e9) time.Sleep(duration) pprof.StopCPUProfile() return w.Bytes(), nil }
func (file *File) Read() ([]interface{}, error) { file.Lock() defer file.Unlock() var b block if err := file.dec.Decode(&b); err != nil { return nil, err } if b.Payload == nil { return nil, circuit.NewError("block without payload") } val, _, err := circuit.Import(b.Payload) return val, err }
/* /dir /dir/... /dir/file */ func parse(s string) (anchor string, file, recurse bool, err error) { s = strings.TrimSpace(s) if len(s) == 0 || s[0] != '/' { return "", false, false, circuit.NewError("invalid anchor") } if len(s) > 3 && s[len(s)-3:] == "..." { recurse = true s = s[:len(s)-3] } _, leaf := path.Split(s) if _, err := circuit.ParseWorkerID(leaf); err == nil { return s, true, false, nil } return s, false, recurse, nil }
func (r *Runtime) Spawn(host string, anchor []string, fn circuit.Func, in ...interface{}) (retrn []interface{}, addr circuit.Addr, err error) { // Catch all errors defer func() { if p := recover(); p != nil { retrn, addr = nil, nil err = circuit.NewError(fmt.Sprintf("spawn panic: %#v", p)) } }() addr, err = worker.Spawn(host, anchor...) if err != nil { return nil, nil, err } return r.remoteGo(addr, fn, in...), addr, nil }
// 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 anchorfs exposes the programming interface for accessing the anchor file system package anchorfs import ( "circuit/use/circuit" "path" "strings" "time" ) var ( ErrName = circuit.NewError("anchor name") ErrNotFound = circuit.NewError("not found") ) // fs represents an anchor file system type fs interface { CreateFile(string, circuit.Addr) error OpenFile(string) (File, error) OpenDir(string) (Dir, error) Created() []string } // Dir is the interface for a directory of workers in the anchor file system type Dir interface { // Name returns the name of the directory
// Expire behaves like Change except, if the expiration interval is // reached, it returns before a change is observed in the directory Expire(expire time.Duration) (children map[string]Info) // Close closes this directory Close() } // Info holds metadata about a node (file or directory) in the file system type Info struct { Name string // Name of the file or sub-directory HasBody bool // True if the Zookeeper node has non-empty data HasChildren bool // True if the Zookeeper node has children } // File is an interface to a file in the durable file system type File interface { // Read reads the contents of this file and returns it in the form of a slice of interfaces Read() ([]interface{}, error) // Write writes a list of interfaces to this file Write(...interface{}) error // Close closes this file Close() error } var ErrParse = circuit.NewError("parse")
func fileRecover(pe *error) { if p := recover(); p != nil { *pe = circuit.NewError("server died") } }
// 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 zdurablefs implements a durable file system using Apache Zookeeper package zdurablefs import ( "circuit/use/circuit" zookeeper "github.com/petar/gozk" "path" ) var ( ErrClosed = circuit.NewError("durable file system: closed") ) // FS implements a durable file system on top of Zookeeper type FS struct { conn *zookeeper.Conn zroot string } func New(conn *zookeeper.Conn, zroot string) *FS { return &FS{conn: conn, zroot: zroot} } func (fs *FS) Remove(fpath string) error { return fs.conn.Delete(path.Join(fs.zroot, fpath), -1) }
// 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 API implements aa REST HTTP API proxy for a sumr database package api import ( "circuit/app/sumr/client" "circuit/kit/sched/limiter" "circuit/use/circuit" ) var ( ErrMode = circuit.NewError("write operation on read-only API") ErrBackend = circuit.NewError("backend") ErrFormat = circuit.NewError("format") ErrFields = circuit.NewError("bad fields") ErrNoValue = circuit.NewError("missing value") ErrNoFeature = circuit.NewError("missing feature") ErrFieldType = circuit.NewError("field type not string") ErrTime = circuit.NewError("time format") ) // API implements a RESTful HTTP API server that accepts JSON requests and // translates them to in-circuit requests to the sumr database cluster. // It can be viewed as a proxy between an external HTTP-capable technology, and // the circuit-backed sumr datastore. // As an added convenience the HTTP API canonically and transparently hashes // JSON values to sumr 64-bit keys. This allows upstream users, e.g. a PHP web app,
func read(rec []string, v interface{}) error { w := reflect.ValueOf(v) for w.Kind() == reflect.Ptr || w.Kind() == reflect.Interface { w = w.Elem() } //t := w.Type() for i := 0; i < w.NumField(); i++ { f := w.Field(i) switch f.Kind() { case reflect.Bool: u, err := strconv.ParseBool(rec[i]) if err != nil { return err } f.SetBool(u) case reflect.Int8: u, err := strconv.ParseInt(rec[i], 10, 8) if err != nil { return err } f.SetInt(u) case reflect.Int16: u, err := strconv.ParseInt(rec[i], 10, 16) if err != nil { return err } f.SetInt(u) case reflect.Int32, reflect.Int: u, err := strconv.ParseInt(rec[i], 10, 32) if err != nil { return err } f.SetInt(u) case reflect.Int64: u, err := strconv.ParseInt(rec[i], 10, 64) if err != nil { return err } f.SetInt(u) case reflect.Uint8: u, err := strconv.ParseUint(rec[i], 10, 8) if err != nil { return err } f.SetUint(u) case reflect.Uint16: u, err := strconv.ParseUint(rec[i], 10, 16) if err != nil { return err } f.SetUint(u) case reflect.Uint32, reflect.Uint: u, err := strconv.ParseUint(rec[i], 10, 32) if err != nil { return err } f.SetUint(u) case reflect.Uint64: u, err := strconv.ParseUint(rec[i], 10, 64) if err != nil { return err } f.SetUint(u) case reflect.Uintptr: return circuit.NewError("unsupported field kind uintptr") case reflect.Float32: u, err := strconv.ParseFloat(rec[i], 32) if err != nil { return err } f.SetFloat(u) case reflect.Float64: u, err := strconv.ParseFloat(rec[i], 64) if err != nil { return err } f.SetFloat(u) case reflect.Complex64: return circuit.NewError("unsupported field kind complex64") case reflect.Complex128: return circuit.NewError("unsupported field kind complex128") case reflect.Array: return circuit.NewError("unsupported field kind array") case reflect.Chan: return circuit.NewError("unsupported field kind chan") case reflect.Func: return circuit.NewError("unsupported field kind func") case reflect.Interface: return circuit.NewError("unsupported field kind interface") case reflect.Map: return circuit.NewError("unsupported field kind map") case reflect.Ptr: return circuit.NewError("unsupported field kind ptr") case reflect.Slice: return circuit.NewError("unsupported field kind slice") case reflect.String: f.SetString(rec[i]) case reflect.Struct: return circuit.NewError("unsupported field kind struct") case reflect.UnsafePointer: return circuit.NewError("unsupported field kind UnsafePointer") default: return circuit.NewError("unknown field kind") } } return nil }
// Copyright 2013 Tumblr, Inc. // // 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 transport import "circuit/use/circuit" var ( ErrEnd = circuit.NewError("end") ErrAlreadyClosed = circuit.NewError("already closed") errCollision = circuit.NewError("conn id collision") ErrNotSupported = circuit.NewError("not supported") ErrAuth = circuit.NewError("authentication") )