// SCHEME://123.3.45.0:3456/2345/R1122334455667788 func ParseAddr(s string) (*Addr, error) { u, err := url.Parse(s) if err != nil { return nil, err } if u.Scheme != n.Scheme { return nil, errors.NewError("worker address URL scheme mismatch") } // Net address naddr, err := ParseNetAddr(u.Host) if err != nil { return nil, err } // Parse path parts := strings.Split(u.Path, "/") if len(parts) != 3 { return nil, errors.NewError(fmt.Sprintf("parse path: %#v", parts)) } if parts[0] != "" { return nil, errors.NewError("must start with slash") } // PID pid, err := strconv.Atoi(parts[1]) if err != nil { return nil, err } // Worker ID id, err := n.ParseWorkerID(parts[2]) if err != nil { return nil, err } return &Addr{ID: id, PID: pid, TCP: naddr.(*net.TCPAddr)}, 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, errors.NewError("no such profile") } var w bytes.Buffer if err := prof.WriteTo(&w, debug); err != nil { return nil, err } return w.Bytes(), nil }
func (d *Dialer) auth(addr n.Addr, conn *blend.Conn) error { defer conn.Close() if err := conn.Write(&HelloMsg{ SourceAddr: d.dialback, TargetAddr: addr, }); err != nil { return err } msg, err := conn.Read() if err != nil { return err } switch q := msg.(type) { case *WelcomeMsg: return nil case *RejectMsg: return errors.NewError("dial rejected by remote (%s)", errors.Unpack(q.Err)) } return errors.NewError("unknown welcome response") }
func (s *Acid) CPUProfile(duration time.Duration) ([]byte, error) { if duration > time.Hour { return nil, errors.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 (r *Runtime) Spawn(host worker.Host, anchor []string, fn circuit.Func, in ...interface{}) (retrn []interface{}, addr n.Addr, err error) { // Catch all errors defer func() { if p := recover(); p != nil { retrn, addr = nil, nil var w bytes.Buffer pprof.Lookup("goroutine").WriteTo(&w, 2) err = errors.NewError(fmt.Sprintf("spawn panic: %#v\nstack:\n%s", p, string(w.Bytes()))) } }() addr, err = worker.Spawn(host, anchor...) if err != nil { return nil, nil, err } return r.remoteGo(addr, fn, in...), addr, nil }
func (l *Listener) handshake(conn *blend.Conn) (sourceAddr *Addr, err error) { if conn == nil { return nil, errors.NewError("listener off") } defer conn.Close() // var msg interface{} msg, err = conn.Read() if err != nil { return nil, err } defer func() { if err != nil { conn.Write(&RejectMsg{err}) } else { err = conn.Write(&WelcomeMsg{}) } }() hello, ok := msg.(*HelloMsg) if !ok { log.Println("rejecting", conn.RemoteAddr().String(), "unknown hello message type") return nil, errors.NewError("rejecting unknown hello type") } // Accept user connections da, ok := hello.SourceAddr.(*Addr) if !ok { log.Println("rejecting", conn.RemoteAddr().String(), "unknown source address type") return nil, errors.NewError("rejecting unknown source address type") } reverseAddr(da, conn.RemoteAddr()) la, ok := hello.TargetAddr.(*Addr) if !ok { log.Println("rejecting ", conn.RemoteAddr().String(), "unknown target address type") return nil, errors.NewError("rejecting unknown target address type") } if la.WorkerID() != l.addr.WorkerID() { log.Println("rejecting", conn.RemoteAddr().String(), "due to worker identity mismatch") return nil, errors.NewError("rejecting worker identity mismatch, looks for %s, got %s", la.WorkerID(), l.addr.WorkerID()) } if la.PID != os.Getpid() { log.Println("rejecting", conn.RemoteAddr().String(), "due to worker PID mismatch") return nil, errors.NewError("rejecting worker PID mismatch, looks for %d, got %d", la.PID, os.Getpid()) } return da, nil }
// 2013 Petar Maymounkov <*****@*****.**> // Package anchorfs exposes the programming interface for accessing the anchor file system package anchorfs import ( "path" "strings" "time" "github.com/gocircuit/circuit/use/errors" "github.com/gocircuit/circuit/use/n" ) var ( ErrName = errors.NewError("anchor name") ErrNotFound = errors.NewError("not found") ) // System represents an anchor file system type System interface { OpenFile(string) (File, error) OpenDir(string) (Dir, error) // Created returns the anchors created by this worker Created() []string } // Rev is the sequentially-increasing revision number of a file system object type Rev int32
nblocked int } func newSniffer(name string) *Sniffer { s := &Sniffer{ name: name, unblock: make(chan struct{}), } runtime.SetFinalizer(s, func(x *Sniffer) { x.warn("•", "Finalizer") x.Close() }) return s } var errWait = errors.NewError("wait") func (s *Sniffer) Printf(format string, arg ...interface{}) { log.Printf("▒ %s ▒ %s", s.name, fmt.Sprintf(format, arg...)) } func (s *Sniffer) report(attr string, p []byte) { s.Printf("%s⟩\n“%s”", attr, string(p)) } func (s *Sniffer) warn(attr, msg string) { s.Printf("%s⟫ “%s”", attr, msg) } func (s *Sniffer) Read(p []byte) (n int, err error) { for {
func fileRecover(pe *error) { if p := recover(); p != nil { *pe = errors.NewError("server died") } }
// // Authors: // 2013 Petar Maymounkov <*****@*****.**> package n import ( "fmt" "hash/fnv" "math/rand" "strconv" "github.com/gocircuit/circuit/use/errors" ) var ErrParse = errors.NewError("parse") // WorkerID represents the identity of a circuit worker process. type WorkerID string // String returns a cononical string representation of this worker ID. func (r WorkerID) String() string { return string(r) } // ChooseWorkerID returns a random worker ID. func ChooseWorkerID() WorkerID { return Int64WorkerID(rand.Int63()) } func Int64WorkerID(src int64) WorkerID {