コード例 #1
0
ファイル: node_test.go プロジェクト: andradeandrey/doozer
func TestNodeSnapshotBad(t *testing.T) {
	buf := bytes.NewBuffer([]byte{})
	gob.NewEncoder(buf).Encode(uint64(1))
	seqnPart := buf.String()

	buf = bytes.NewBuffer([]byte{})
	gob.NewEncoder(buf).Encode(emptyDir)
	valPart := buf.String()
	valPart = valPart[0 : len(valPart)/2]

	m := seqnPart + valPart
	n, e := emptyDir.apply(1, m)
	assert.Equal(t, emptyDir, n)
	assert.Equal(t, Event{2, "", "", "", m, io.ErrUnexpectedEOF, n}, e)
}
コード例 #2
0
ファイル: gob.go プロジェクト: vanackere/replican-sync
func (block *Block) GobEncode() ([]byte, error) {
	buffer := bytes.NewBuffer([]byte{})
	encoder := gob.NewEncoder(buffer)

	var err error
	err = encoder.EncodeValue(reflect.ValueOf(gobNodeVersion))
	if err != nil {
		return nil, err
	}

	err = encoder.EncodeValue(reflect.ValueOf(&block.position))
	if err != nil {
		return nil, err
	}
	encoder.EncodeValue(reflect.ValueOf(&block.weak))
	if err != nil {
		return nil, err
	}
	encoder.EncodeValue(reflect.ValueOf(&block.strong))
	if err != nil {
		return nil, err
	}

	return buffer.Bytes(), nil
}
コード例 #3
0
ファイル: gob.go プロジェクト: vanackere/replican-sync
func (dir *Dir) GobEncode() ([]byte, error) {
	buffer := bytes.NewBuffer([]byte{})
	encoder := gob.NewEncoder(buffer)

	var err error
	err = encoder.EncodeValue(reflect.ValueOf(gobNodeVersion))
	if err != nil {
		return nil, err
	}

	err = encoder.EncodeValue(reflect.ValueOf(&dir.name))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&dir.mode))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&dir.strong))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&dir.SubDirs))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&dir.Files))
	if err != nil {
		return nil, err
	}

	return buffer.Bytes(), nil
}
コード例 #4
0
ファイル: key.go プロジェクト: ashokgelal/gorilla
func (k *Key) GobEncode() ([]byte, error) {
	buf := new(bytes.Buffer)
	if err := gob.NewEncoder(buf).Encode(keyToGobKey(k)); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}
コード例 #5
0
ファイル: msg.go プロジェクト: fedgrant/tonika
// Encipher a message
func EncipherMsg(plaintext []byte, pubkey *CipherMsgPubKey) ([]byte, os.Error) {
	msg := &U_CipherMsg{
		Text: make([]byte, len(plaintext)),
	}
	n := copy(msg.Text, plaintext)
	if n != len(plaintext) {
		panic("crypto, copy text")
	}
	urand := NewTimedRand()
	seed := make([]byte, cipherMsgSeedLen)
	n, _ = urand.Read(seed)
	if n != len(seed) {
		panic("crypto,gen seed")
	}
	cseed, err := EncryptShortMsg(pubkey.rsa, seed, []byte(""))
	if err != nil {
		return nil, err
	}
	msg.Seed = cseed
	rc, err := rc4.NewCipher(seed)
	if err != nil {
		panic("rc4tube")
	}
	rc.XORKeyStream(msg.Text)
	var w bytes.Buffer
	enc := gob.NewEncoder(&w)
	err = enc.Encode(msg)
	if err != nil {
		return nil, err
	}
	return w.Bytes(), nil
}
コード例 #6
0
ファイル: server.go プロジェクト: pcgod/grumble
func (server *Server) handleFreezeRequest(freq *freezeRequest, fs *frozenServer) {
	pr, pw := io.Pipe()

	freq.readCloser = pr
	freq.done <- true

	zw, err := gzip.NewWriterLevel(pw, gzip.BestCompression)
	if err != nil {
		if err = pw.CloseWithError(err); err != nil {
			log.Panicf("Unable to close PipeWriter: %v", err.String())
		}
		return
	}

	enc := gob.NewEncoder(zw)
	err = enc.Encode(fs)
	if err != nil {
		if err = pw.CloseWithError(err); err != nil {
			log.Panicf("Unable to close PipeWriter: %v", err.String())
		}
	}

	if err = pw.CloseWithError(zw.Close()); err != nil {
		log.Panicf("Unable to close PipeWriter: %v", err.String())
	}
}
コード例 #7
0
ファイル: persist.go プロジェクト: qtse/go_fetch
func RetrieveActDetails(c appengine.Context, actId int) (res *ActDetail, err os.Error) {
	var d DSActDetail
	if itm, err := memcache.Get(c, "actId__"+strconv.Itoa(actId)); err != nil && err != memcache.ErrCacheMiss {
		return nil, err
	} else if err == nil {
		// Cache hit
		buf := bytes.NewBuffer(itm.Value)
		dec := gob.NewDecoder(buf)
		dec.Decode(&d)
	} else {
		// Cache miss
		key := datastore.NewKey(c, "DSActDetail", "", int64(actId), nil)
		if err := datastore.Get(c, key, &d); err == datastore.ErrNoSuchEntity {
			return &ActDetail{ActId: actId}, nil
		} else if err != nil {
			return nil, err
		}
		buf := bytes.NewBufferString("")
		enc := gob.NewEncoder(buf)
		enc.Encode(d)

		itm := &memcache.Item{
			Key:   "actId__" + strconv.Itoa(actId),
			Value: buf.Bytes(),
		}

		err = memcache.Set(c, itm)
		c.Debugf("Request cache to memcache")
	}
	return d.fromDS(), nil
}
コード例 #8
0
ファイル: query_parameter.go プロジェクト: ssrl/gosqlite3
func (p QueryParameter) Bind(s *Statement, value interface{}) (e os.Error) {
	var rv Errno
	switch v := value.(type) {
	case nil:
		rv = Errno(C.sqlite3_bind_null(s.cptr, C.int(p)))
	case int:
		rv = Errno(C.sqlite3_bind_int(s.cptr, C.int(p), C.int(v)))
	case string:
		rv = Errno(C.gosqlite3_bind_text(s.cptr, C.int(p), C.CString(v), C.int(len(v))))
	case int64:
		rv = Errno(C.sqlite3_bind_int64(s.cptr, C.int(p), C.sqlite3_int64(v)))
	case float32:
		rv = Errno(C.sqlite3_bind_double(s.cptr, C.int(p), C.double(v)))
	case float64:
		rv = Errno(C.sqlite3_bind_double(s.cptr, C.int(p), C.double(v)))
	default:
		buffer := new(bytes.Buffer)
		encoder := gob.NewEncoder(buffer)
		if encoder.Encode(value) != nil {
			rv = ENCODER
		} else {
			rawbuffer := string(buffer.Bytes())
			rv = Errno(C.gosqlite3_bind_blob(s.cptr, C.int(p), unsafe.Pointer(C.CString(rawbuffer)), C.int(len(rawbuffer))))
		}
	}
	if rv != OK {
		e = rv
	}
	return
}
コード例 #9
0
ファイル: flatcache.go プロジェクト: ipeet/camlistore
func (c *FlatHaveCache) Save() {
	c.mu.Lock()
	defer c.mu.Unlock()
	if len(c.dirty) == 0 {
		cachelog.Printf("FlatHaveCache: Save, but nothing dirty")
		return
	}

	f, err := os.OpenFile(c.filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0600)
	if err != nil {
		log.Fatalf("FlatHaveCache OpenFile: %v", err)
	}
	defer f.Close()
	e := gob.NewEncoder(f)
	write := func(v interface{}) {
		if err := e.Encode(v); err != nil {
			panic("Encode: " + err.String())
		}
	}
	for k, _ := range c.dirty {
		write(k)
	}
	c.dirty = make(map[string]bool)
	cachelog.Printf("FlatHaveCache: saved")
}
コード例 #10
0
ファイル: tree_parser.go プロジェクト: sim82/go_tools
func main() {
	data, _ := ioutil.ReadFile("/space/raxml/VINCENT/RAxML_bipartitions.1604.BEST.WITH")

	n, _ := Parse(StringPI(string(data)), 0)
	//n,_ := Parse( StringPI(" (bla:.1,bla2:2.1,(bla32:1.2,bla34:0.7)100:3.4);"), 0 );

	PrintTree(n, os.Stdout)
	fmt.Println()
	PrintTree(n.Back, os.Stdout)
	fmt.Println()

	i := make([]int, 4)
	i[0] = 72
	i[1] = 105
	i[2] = 32
	i[3] = 9731 // Unicode snowman
	var s string = string(i)
	fmt.Printf("%s has length %d bytes.\n", s, len(s))

	buf := bytes.NewBuffer(nil)

	enc := gob.NewEncoder(buf)
	enc.Encode(n)

	os.Stdout.Write(buf.Bytes())
}
コード例 #11
0
func gobMarshal(v interface{}) ([]byte, os.Error) {
	var buf bytes.Buffer
	if err := gob.NewEncoder(&buf).Encode(v); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}
コード例 #12
0
ファイル: gob.go プロジェクト: vanackere/replican-sync
func (file *File) GobEncode() ([]byte, error) {
	buffer := bytes.NewBuffer([]byte{})
	encoder := gob.NewEncoder(buffer)

	var err error
	err = encoder.EncodeValue(reflect.ValueOf(gobNodeVersion))
	if err != nil {
		return nil, err
	}

	err = encoder.EncodeValue(reflect.ValueOf(&file.name))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&file.mode))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&file.strong))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&file.Size))
	if err != nil {
		return nil, err
	}
	err = encoder.EncodeValue(reflect.ValueOf(&file.Blocks))
	if err != nil {
		return nil, err
	}

	return buffer.Bytes(), nil
}
コード例 #13
0
ファイル: rat_test.go プロジェクト: Sunmonds/gcc
func TestRatGobEncoding(t *testing.T) {
	var medium bytes.Buffer
	enc := gob.NewEncoder(&medium)
	dec := gob.NewDecoder(&medium)
	for i, test := range gobEncodingTests {
		for j := 0; j < 4; j++ {
			medium.Reset() // empty buffer for each test case (in case of failures)
			stest := test
			if j&1 != 0 {
				// negative numbers
				stest = "-" + test
			}
			if j%2 != 0 {
				// fractions
				stest = stest + "." + test
			}
			var tx Rat
			tx.SetString(stest)
			if err := enc.Encode(&tx); err != nil {
				t.Errorf("#%d%c: encoding failed: %s", i, 'a'+j, err)
			}
			var rx Rat
			if err := dec.Decode(&rx); err != nil {
				t.Errorf("#%d%c: decoding failed: %s", i, 'a'+j, err)
			}
			if rx.Cmp(&tx) != 0 {
				t.Errorf("#%d%c: transmission failed: got %s want %s", i, 'a'+j, &rx, &tx)
			}
		}
	}
}
コード例 #14
0
ファイル: store_test.go プロジェクト: andradeandrey/doozer
func TestSnapshotBad(t *testing.T) {
	buf := bytes.NewBuffer([]byte{})
	gob.NewEncoder(buf).Encode(uint64(1))
	seqnPart := buf.String()

	buf = bytes.NewBuffer([]byte{})
	gob.NewEncoder(buf).Encode(emptyDir)
	valPart := buf.String()
	valPart = valPart[0 : len(valPart)/2]

	st := New()
	st.Ops <- Op{1, seqnPart + valPart}
	st.Sync(1)

	// check that we aren't leaking memory
	assert.Equal(t, 0, len(st.todo))
}
コード例 #15
0
ファイル: sessions.go プロジェクト: klinster/Bessie
// serialize encodes a session value using gob.
func serialize(session SessionData) ([]byte, error) {
	b := bytes.NewBuffer(nil)
	e := gob.NewEncoder(b)
	if err := e.Encode(session); err != nil {
		return nil, err
	}
	return b.Bytes(), nil
}
コード例 #16
0
ファイル: tGene.go プロジェクト: ericfode/Datazome
func (Tgene *TGene) Save(file io.Writer) {
	enc := gob.NewEncoder(file)
	err := enc.Encode(Tgene)
	if err != nil {
		panic(err.String())
	}
	return
}
コード例 #17
0
ファイル: recipe_test.go プロジェクト: newblue/recipe
func TestMe(t *testing.T) {
	if len(Recipe_list) == 0 {
		t.Error(":(")
	}
	e := gob.NewEncoder(os.Stdout)
	//r := Recipe_list[0]
	e.Encode(Recipe_list)
}
コード例 #18
0
ファイル: delay.go プロジェクト: ashokgelal/gorilla
// Call invokes a delayed function.
// Note that the function will be executed later.
func (f *Function) Call(c appengine.Context, args ...interface{}) {
	if f.err != nil {
		c.Errorf("delay: func is invalid: %v", f.err)
		return
	}

	nArgs := len(args) + 1 // +1 for the appengine.Context
	ft := f.fv.Type()
	minArgs := ft.NumIn()
	if ft.IsVariadic() {
		minArgs--
	}
	if nArgs < minArgs {
		c.Errorf("delay: too few arguments to func: %d < %d", nArgs, minArgs)
		return
	}
	if !ft.IsVariadic() && nArgs > minArgs {
		c.Errorf("delay: too many arguments to func: %d > %d", nArgs, minArgs)
		return
	}

	// Check arg types.
	for i := 1; i < nArgs; i++ {
		at := reflect.TypeOf(args[i-1])
		var dt reflect.Type
		if i < minArgs {
			// not a variadic arg
			dt = ft.In(i)
		} else {
			// a variadic arg
			dt = ft.In(minArgs).Elem()
		}
		if !at.AssignableTo(dt) {
			c.Errorf("delay: argument %d has wrong type: %v is not assignable to %v", i, at, dt)
			return
		}
	}

	inv := invocation{
		Key:  f.key,
		Args: args,
	}

	buf := new(bytes.Buffer)
	if err := gob.NewEncoder(buf).Encode(inv); err != nil {
		c.Errorf("delay: gob encoding failed: %v", err)
		return
	}

	task := &taskqueue.Task{
		Path:    path,
		Payload: buf.Bytes(),
	}
	if _, err := taskqueueAdder(c, task, queue); err != nil {
		c.Errorf("delay: taskqueue.Add failed: %v", err)
		return
	}
}
コード例 #19
0
ファイル: cartdb.go プロジェクト: shellreef/gones
// Write the game database in a fast binary Go-specific format
func WriteGob(filename string, database *Database) {
	f, err := os.Open(filename, os.O_WRONLY|os.O_TRUNC|os.O_CREAT, 0x1a4) // 0644
	if err != nil {
		panic(fmt.Sprintf("error saving %s: %s", filename, err))
	}

	e := gob.NewEncoder(f)
	e.Encode(database)
}
コード例 #20
0
ファイル: huffman.go プロジェクト: kravitz/moroz
func putMetaInfo(fin, fout *os.File, cb []cbRecord) {
	var meta nMeta
	meta.Cb = make([]cbRecord, 256)
	for k, v := range cb {
		meta.Cb[k] = v
	}
	meta.Fsize = GetFileSize(fin)
	PanicIf(gob.NewEncoder(fout).Encode(meta))
}
コード例 #21
0
ファイル: util.go プロジェクト: fedgrant/tonika
func newEncodeDecodeCloser(rwc io.ReadWriteCloser) *EncodeDecodeCloser {
	p := prof.NewReadWriteCloser(rwc)
	return &EncodeDecodeCloser{
		p,
		gob.NewEncoder(p),
		gob.NewDecoder(p),
		p,
	}
}
コード例 #22
0
ファイル: client.go プロジェクト: 8l/go-learn
// NewClient returns a new Client to handle requests to the
// set of services at the other end of the connection.
func NewClient(conn io.ReadWriteCloser) *Client {
	client := new(Client);
	client.conn = conn;
	client.enc = gob.NewEncoder(conn);
	client.dec = gob.NewDecoder(conn);
	client.pending = make(map[uint64]*Call);
	go client.input();
	return client;
}
コード例 #23
0
func saveToken(file string, token *oauth.Token) {
	f, err := os.Create(file)
	if err != nil {
		log.Printf("Warning: failed to cache oauth token: %v", err)
		return
	}
	defer f.Close()
	gob.NewEncoder(f).Encode(token)
}
コード例 #24
0
ファイル: writer.go プロジェクト: fedgrant/tonika
func MakeFileWriter(fileprefix string) (*FileWriter, os.Error) {
	w := &FileWriter{prefix: fileprefix}
	err := w.recycle()
	if err != nil {
		return nil, err
	}
	w.enc = gob.NewEncoder(w)
	return w, nil
}
コード例 #25
0
ファイル: lunchTracker.go プロジェクト: patricklucas/Go2Lunch
func (t *LunchTracker) persist(poll LunchPoll) {
	file, err := os.Open(*dataFile, os.O_WRONLY|os.O_CREATE, 0600)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	encode := gob.NewEncoder(file)
	encode.Encode(poll)
}
コード例 #26
0
ファイル: store.go プロジェクト: andradeandrey/doozer
// Encodes the entire storage state, including the current sequence number, as
// a mutation. This mutation can be applied to an empty store to reproduce the
// state of `s`.
//
// Returns the sequence number of the snapshot and the mutation itself.
//
// A snapshot must be applied at sequence number 1. Once a snapshot has been
// applied, the store's sequence number will be set to `seqn`.
//
// Note that applying a snapshot does not send notifications.
func (st *Store) Snapshot() (seqn uint64, mutation string) {
	w := new(bytes.Buffer)

	// WARNING: Be sure to read the pointer value of st.state only once. If you
	// need multiple accesses, copy the pointer first.
	ss := st.state

	err := gob.NewEncoder(w).Encode(ss.ver)
	if err != nil {
		panic(err)
	}

	err = gob.NewEncoder(w).Encode(ss.root)
	if err != nil {
		panic(err)
	}

	return ss.ver, w.String()
}
コード例 #27
0
ファイル: tube.go プロジェクト: fedgrant/tonika
func NewTube(rwc io.ReadWriteCloser, r *bufio.Reader) *Tube {
	if r == nil {
		r = bufio.NewReader(rwc)
	}
	return &Tube{
		ReadWriteCloser: rwc,
		Reader:          r,
		Encoder:         gob.NewEncoder(rwc),
		Decoder:         gob.NewDecoder(r),
	}
}
コード例 #28
0
ファイル: client.go プロジェクト: trojanspike/ampify
func Dial() *rpc.Client {
	httpClient := &http.Client{}
	buf := &bytes.Buffer{}
	codec := &Codec{
		client: httpClient,
		enc:    gob.NewEncoder(buf),
		encBuf: buf,
	}
	codec.m.Lock()
	return rpc.NewClientWithCodec(codec)
}
コード例 #29
0
ファイル: fs_test.go プロジェクト: vanackere/replican-sync
func TestGobbable(t *testing.T) {
	tg := treegen.New()
	treeSpec := tg.D("foo",
		tg.D("bar",
			tg.D("aleph",
				tg.F("A", tg.B(42, 65537)),
				tg.F("a", tg.B(42, 65537))),
			tg.D("beth",
				tg.F("B", tg.B(43, 65537)),
				tg.F("b", tg.B(43, 65537))),
			tg.D("jimmy",
				tg.F("G", tg.B(44, 65537)),
				tg.F("g", tg.B(44, 65537)))),
		tg.D("baz",
			tg.D("uno",
				tg.F("1", tg.B(1, 65537)),
				tg.F("I", tg.B(1, 65537))),
			tg.D("dos",
				tg.F("2", tg.B(11, 65537)),
				tg.F("II", tg.B(11, 65537))),
			tg.D("tres",
				tg.F("3", tg.B(111, 65537)),
				tg.F("III", tg.B(111, 65537)))))

	path := treegen.TestTree(t, treeSpec)
	defer os.RemoveAll(path)

	foo, err := IndexDir(filepath.Join(path, "foo"))
	assert.Tf(t, err == nil, "%v", err)

	node, found := foo.Resolve(filepath.Join("bar", "aleph", "A"))
	assert.Equal(t, filepath.Join("bar", "aleph", "A"), RelPath(node))

	bufferEnc := bytes.NewBuffer([]byte{})
	encoder := gob.NewEncoder(bufferEnc)
	err = encoder.Encode(foo)
	assert.Tf(t, err == nil, "%v", err)

	bufferDec := bytes.NewBuffer(bufferEnc.Bytes())
	decoder := gob.NewDecoder(bufferDec)

	decFoo := &Dir{}
	err = decoder.Decode(decFoo)
	assert.Tf(t, err == nil, "%v", err)

	node, found = decFoo.Resolve(filepath.Join("bar", "aleph", "A"))
	assert.T(t, found)
	_, isFile := node.(*File)
	assert.T(t, isFile)

	assert.T(t, node.Parent() != nil)
	assert.Equal(t, filepath.Join("bar", "aleph", "A"), RelPath(node))
}
コード例 #30
0
ファイル: store.go プロジェクト: rayleyva/goto
func (s *URLStore) saveLoop(filename string) {
	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
	if err != nil {
		log.Fatal("URLStore:", err)
	}
	e := gob.NewEncoder(f)
	for {
		r := <-s.save
		if err := e.Encode(r); err != nil {
			log.Println("URLStore:", err)
		}
	}
}