Esempio n. 1
1
func TestJsonHelperGobEncoding(t *testing.T) {
	raw := `{"testing": 123,"name":"bob & more"}`
	reader := strings.NewReader(raw)
	jh, err := NewJsonHelperReader(reader)
	assert.Tf(t, err == nil, "Unexpected error decoding gob: %s", err)
	assert.Tf(t, jh.Int("testing") == 123, "Unexpected value in gob: %d", jh.Int("testing"))
	var buf bytes.Buffer
	err = gob.NewEncoder(&buf).Encode(&jh)
	assert.T(t, err == nil, err)

	var jhNew JsonHelper
	err = gob.NewDecoder(&buf).Decode(&jhNew)
	assert.T(t, err == nil, err)
	assert.Tf(t, jhNew.Int("testing") == 123, "Unexpected value in gob: %d", jhNew.Int("testing"))
	assert.Tf(t, jhNew.String("name") == "bob & more", "Unexpected value in gob: %d", jhNew.String("name"))

	buf2 := bytes.Buffer{}
	gt := GobTest{"Hello", jh}
	err = gob.NewEncoder(&buf2).Encode(&gt)
	assert.T(t, err == nil, err)

	var gt2 GobTest
	err = gob.NewDecoder(&buf2).Decode(&gt2)
	assert.T(t, err == nil, err)
	assert.Tf(t, gt2.Name == "Hello", "Unexpected value in gob: %d", gt2.Name)
	assert.Tf(t, gt2.Data.Int("testing") == 123, "Unexpected value in gob: %d", gt2.Data.Int("testing"))
	assert.Tf(t, gt2.Data.String("name") == "bob & more", "Unexpected value in gob: %d", gt2.Data.String("name"))
}
Esempio n. 2
0
func encryptDispatch(conn net.Conn, m Message) error {
	// We want to sent encrypted data.
	// In order to encrypt, we need to first serialize the message.
	// In order to sent/receive hassle free, we need to serialize the encrypted message
	// So: msg -> [GOB] -> [ENCRYPT] -> [GOB] -> (dispatch)

	// Create encrypter
	var encMsg bytes.Buffer
	encrypter, err := saltsecret.NewWriter(&encMsg, conf.Key, saltsecret.ENCRYPT, true)
	if err != nil {
		return err
	}

	// Serialize message
	enc := gob.NewEncoder(encrypter)
	if err = enc.Encode(m); err != nil {
		return err
	}

	// Flush encrypter to actuall encrypt the message
	if err = encrypter.Flush(); err != nil {
		return err
	}

	// Serialize encrypted message and dispatch it
	dispatch := gob.NewEncoder(conn)
	if err = dispatch.Encode(encMsg.Bytes()); err != nil {
		return err
	}

	return nil
}
Esempio n. 3
0
// When checkpointing the system, encode the non-public interface into the Val,
// followed by a normal encoding of the struct
func (m *MutState) GobEncode() ([]byte, error) {

	if !m.v.IsValid() {
		return nil, fmt.Errorf("Trying to checkpoint a mutable state with a pointer from a previous ceckpoint")
	}

	var b bytes.Buffer
	enc := gob.NewEncoder(&b)
	if err := enc.EncodeValue(m.v.Elem()); err != nil {
		return nil, err
	}
	m.Val = b.Bytes()

	var buff bytes.Buffer

	enc = gob.NewEncoder(&buff)
	if err := enc.Encode(m.KT); err != nil {
		return nil, err
	}
	if err := enc.Encode(m.Val); err != nil {
		return nil, err
	}

	return buff.Bytes(), nil
}
Esempio n. 4
0
/*
 * send connections to nodes with greater Names
 * and stores connections into connections map
 * @param	latterNodes
 *			map that contains all nodes with greater or equal Node names
 *
 * @param	LocalNode
 **/
func sendConnection(latterNodes map[string]Node) {
	defer wg.Done()
	for _, node := range latterNodes {
		conn, err := net.Dial("tcp", node.IP+":"+strconv.Itoa(node.Port))
		for err != nil {
			fmt.Print(".")
			time.Sleep(time.Second * 1)
			conn, err = net.Dial("tcp", node.IP+":"+strconv.Itoa(node.Port))
		}
		if node.Name == LocalNode.Name {
			localConn = conn
			localEncoder = gob.NewEncoder(conn)
		} else {
			addConnection(node.Name, conn)
		}

		/* send an initial ping message to other side of the connection */
		timestampMutex.Lock()
		msg := Message{LocalNode.Name, node.Name, "ping", "ping", 0, vectorTimeStamp}
		timestampMutex.Unlock()
		encoder := gob.NewEncoder(conn)
		encoder.Encode(msg)
	}
	fmt.Println()
}
Esempio n. 5
0
func CreateGobsFile(targetFilePath string, recs *[]interface{}, getRecPtr GobRecPtrMaker, gzipped bool) {
	var file, err = os.Create(targetFilePath)
	var gobber *gob.Encoder
	var gzipper *gzip.Writer
	if file != nil {
		defer file.Close()
	}
	if err != nil {
		panic(err)
	}
	if gzipped {
		if gzipper, err = gzip.NewWriterLevel(file, gzip.BestCompression); gzipper != nil {
			defer gzipper.Close()
			gobber = gob.NewEncoder(gzipper)
		}
		if err != nil {
			panic(err)
		}
	} else {
		gobber = gob.NewEncoder(file)
	}
	for _, rec := range *recs {
		if err = gobber.Encode(coreutil.PtrVal(getRecPtr(rec))); err != nil {
			panic(err)
		}
	}
}
Esempio n. 6
0
File: rcf.go Progetto: reusee/rcf
func (f *File) encode(o interface{}) (bs []byte, err error) {
	buf := new(bytes.Buffer)
	if f.compressMethod == _COMPRESS_SNAPPY {
		w := snappy.NewWriter(buf)
		if f.codec == _CODEC_GOB {
			err = gob.NewEncoder(w).Encode(o)
		} else if f.codec == _CODEC_MSGPACK {
			err = msgpack.NewEncoder(w).Encode(o)
		}
		if err != nil {
			return nil, err
		}
		err = w.Close()
		if err != nil {
			return nil, err
		}
	} else {
		if f.codec == _CODEC_GOB {
			err = gob.NewEncoder(buf).Encode(o)
		} else if f.codec == _CODEC_MSGPACK {
			err = msgpack.NewEncoder(buf).Encode(o)
		}
		if err != nil {
			return nil, err
		}
	}
	return buf.Bytes(), nil
}
Esempio n. 7
0
func sendWork(c net.Conn, workchan chan Work, clientId int) {
	for {
		// assign works until workchan close
		select {
		case work, ok := <-workchan:
			if ok {
				fmt.Printf("[INFO]Assigned work to [%d-%d] to client %d\n", work.StartVal, work.EndVal, clientId)
				encoder := gob.NewEncoder(c)
				err := encoder.Encode(work)
				if err != nil {
					fmt.Printf("[ERROR]Client %d disconnected, lost Job [%d-%d]\n", clientId, work.StartVal, work.EndVal)
					return
				}
			} else {
				// if workchan is closed, send complete message to worker
				encoder := gob.NewEncoder(c)
				err := encoder.Encode(Work{-1, 0, "", ""})
				if err != nil {
					fmt.Printf("[ERROR]Send complete message to client %d failed\n", clientId)
				}
				return
			}
		default:
			time.Sleep(1 * time.Second)
		}
	}
}
Esempio n. 8
0
// Store stores a fuzz.FuzzReport and the binaryFuzzNames associated with it to the underlying
// fuzz.FuzzReportCache. It creates a bucket with the
// name of the given revision and stores the report as a []byte under a simple key.
func (b *FuzzReportCache) Store(report fuzz.FuzzReportTree, binaryFuzzNames []string, revision string) error {
	storeFunc := func(tx *bolt.Tx) error {
		bkt, err := tx.CreateBucketIfNotExists([]byte(revision))
		if err != nil {
			return fmt.Errorf("Could not make cache/bucket for %s", revision)
		}
		var buffReport bytes.Buffer
		enc := gob.NewEncoder(&buffReport)
		if err := enc.Encode(report); err != nil {
			return fmt.Errorf("Problem encoding report: %s", err)
		}
		if err := bkt.Put(REPORT_KEY, buffReport.Bytes()); err != nil {
			return fmt.Errorf("Problem storing %d bytes of report: %s", buffReport.Len(), err)
		}
		var buffNames bytes.Buffer
		enc = gob.NewEncoder(&buffNames)
		if err := enc.Encode(binaryFuzzNames); err != nil {
			return fmt.Errorf("Problem encoding fuzz names: %s", err)
		}
		if err := bkt.Put(BINARY_FUZZES_KEY, buffNames.Bytes()); err != nil {
			return fmt.Errorf("Problem storing %d bytes of binaryFuzzNames: %s", buffNames.Len(), err)
		}
		return nil
	}
	return b.DB.Update(storeFunc)
}
Esempio n. 9
0
func (zip GobMeddler) PreWrite(field interface{}) (saveValue interface{}, err error) {
	buffer := new(bytes.Buffer)

	if zip {
		// gob encode and gzip
		gzipWriter := gzip.NewWriter(buffer)
		defer gzipWriter.Close()
		gobEncoder := gob.NewEncoder(gzipWriter)
		if err := gobEncoder.Encode(field); err != nil {
			return nil, fmt.Errorf("Gob encoding/gzip error: %v", err)
		}
		if err := gzipWriter.Close(); err != nil {
			return nil, fmt.Errorf("Closing gzip writer: %v", err)
		}

		return buffer.Bytes(), nil
	}

	// gob encode
	gobEncoder := gob.NewEncoder(buffer)
	if err := gobEncoder.Encode(field); err != nil {
		return nil, fmt.Errorf("Gob encoding error: %v", err)
	}
	return buffer.Bytes(), nil
}
Esempio n. 10
0
/*********************************************************************
	Logic for Server
*********************************************************************/
func handleClient(conn net.Conn) {

	for {
		var err error
		var request string

		err = gob.NewDecoder(conn).Decode(&request)

		if err != nil {
			conn.Write([]byte("Error in 'reading' data at server."))
			return
		}

		// -------------------
		// Logic at Server
		// -------------------
		comm := strings.Split(request, " ")
		response := data_pkt{}

		if comm[0] == "set" {
			kvs[comm[1]] = comm[2]
			response.Status = true
			response.Msg = kvs[comm[1]] + " got added successfully."
			err = gob.NewEncoder(conn).Encode(response)
		} else if comm[0] == "get" {
			value, status := kvs[comm[1]]
			if status == true {
				response.Status = true
				response.Msg = value
				err = gob.NewEncoder(conn).Encode(response)
			} else {
				response.Status = false
				response.Msg = "Error!!! \nNo key exists."
				err = gob.NewEncoder(conn).Encode(response)
			}
		} else if comm[0] == "delete" {
			temp, ok := kvs[comm[1]]

			if temp == "" && ok == false {
				response.Status = false
				response.Msg = comm[1] + " does not exists in K.V.Store ."
				err = gob.NewEncoder(conn).Encode(response)
			} else {
				delete(kvs, comm[1])
				response.Status = true
				response.Msg = comm[1] + " got deleted."
				err = gob.NewEncoder(conn).Encode(response)
			}
		}

		checkError(err)

		if err != nil {
			conn.Write([]byte("Error Occurred in Server somewhere."))
			return
		}

	}

}
Esempio n. 11
0
/* Connection to this node's supernode(s) or fellow local nodes*/
func (m *Messenger) clientSocket(name string, address string, conn_type int) {
	conn, err := net.Dial("tcp", fmt.Sprintf("%v", address))
	defer conn.Close()
	if err != nil {
		fmt.Printf("ERROR: Failed to connect to %v on address %v\n", name, address)
		return
	}
	fmt.Printf("Connected to %v on address %v\n", name, address)

	dec := gob.NewDecoder(conn)

	//Add new connection to either the global or local connections/encoders
	if conn_type == mylib.GLOBAL_INTRODUCTION {
		m.global_conns = append(m.global_conns, &conn)
		m.global_encoders[name] = gob.NewEncoder(conn)
		m.global_encoders[name].Encode(&mylib.Message{"", m.name, m.name, name, m.Is_supernode, conn_type, m.v_clock.CurTime()})
		defer delete(m.global_encoders, name)
	} else {
		m.local_conns = append(m.local_conns, &conn)
		m.local_encoders[name] = gob.NewEncoder(conn)
		m.local_encoders[name].Encode(&mylib.Message{"", m.name, m.name, name, m.Is_supernode, conn_type, m.v_clock.CurTime()})
		defer delete(m.local_encoders, name)
	}

	//Start message listening loop
	m.receive_messages(name, dec)
}
Esempio n. 12
0
func generateKeyPair() (genResult bool) {

	// Generate private key
	privatekey, err := rsa.GenerateKey(rand.Reader, 1024) // Maybe increase size?

	if err != nil {
		fmt.Println(err.Error)
		os.Exit(1)
	}

	var publickey *rsa.PublicKey
	publickey = &privatekey.PublicKey

	// Save private and public key
	privatekeyfile, err := os.Create(PVT_KEY_PATH)
	if err != nil {
		fmt.Println(err)
		genResult = false
	}
	privatekeyencoder := gob.NewEncoder(privatekeyfile)
	privatekeyencoder.Encode(privatekey)
	privatekeyfile.Close()

	publickeyfile, err := os.Create(PUB_KEY_PATH)
	if err != nil {
		fmt.Println(err)
		genResult = false
	}
	publickeyencoder := gob.NewEncoder(publickeyfile)
	publickeyencoder.Encode(publickey)
	publickeyfile.Close()

	// Save PEM file
	pemfile, err := os.Create(PVT_PEM_PATH)

	if err != nil {
		fmt.Println(err)
		genResult = false
	}

	// http://golang.org/pkg/encoding/pem/#Block
	var pemkey = &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(privatekey)}

	err = pem.Encode(pemfile, pemkey)

	if err != nil {
		fmt.Println(err)
		genResult = false
	}

	pemfile.Close()

	genResult = true

	return

}
Esempio n. 13
0
File: codec.go Progetto: vgp/gogp
func NewGobCodecs(conn io.ReadWriteCloser) (*gobServerCodec, *gobClientCodec) {
	sbuf := bufio.NewWriter(conn)
	srv := &gobServerCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(sbuf), sbuf}

	cbuf := bufio.NewWriter(conn)
	cli := &gobClientCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(cbuf), cbuf}

	return srv, cli
}
func NewGobConnection(conn net.Conn) GobConnection {
	if gcn, ok := gobPool.Get().(*gobConnection); ok {
		gcn.rwc = conn
		gcn.enc = gob.NewEncoder(conn)
		gcn.dec = gob.NewDecoder(conn)
		return gcn
	}
	return &gobConnection{rwc: conn, enc: gob.NewEncoder(conn), dec: gob.NewDecoder(conn)}
}
Esempio n. 15
0
func main() {
	flag.Parse()

	conn, ch := qutils.GetChannel(url)
	defer conn.Close()
	defer ch.Close()

	dataQueue := qutils.GetQueue(*name, ch, false)

	publishQueueName(ch)

	discoveryQueue := qutils.GetQueue("", ch, true)

	ch.QueueBind(
		discoveryQueue.Name,
		"",
		qutils.SensorDiscoveryExchange,
		false,
		nil)

	go listenForDiscoveryRequests(discoveryQueue.Name, ch)

	dur, _ := time.ParseDuration(strconv.Itoa(1000/int(*freq)) + "ms")

	signal := time.Tick(dur)

	buf := new(bytes.Buffer)
	enc := gob.NewEncoder(buf)

	for range signal {
		calcValue()

		reading := dto.SensorMessage{
			Name:      *name,
			Value:     value,
			Timestamp: time.Now(),
		}

		buf.Reset()
		enc = gob.NewEncoder(buf)
		enc.Encode(reading)

		msg := amqp.Publishing{
			Body: buf.Bytes(),
		}

		ch.Publish(
			"",             // exchange name
			dataQueue.Name, // key string
			false,          // mandatory bool
			false,          // immediate bool
			msg)            // msg amqp.Publish

		log.Printf("Reading sent. Value: %v\n", value)
	}
}
Esempio n. 16
0
// Send implements mpi.Interface.Send. Network uses the encoding/gob package to
// serialize data.
func (n *Network) Send(data interface{}, destination, tag int) error {

	/*
		Implementation comments:
		The mpi.Interface.Send specifies that sends between two nodes may happen
		concurrently as long as the tags are unique. These concurrent sends may
		have different data types, but the program must know the type of data in
		order to decode from the communication channel. The solution to this is
		to serialize all of the data into a []byte, and to only send the "message"
		type over the channel. Gob can decode the message, observe the tag, and
		pass along the []byte to receive for further decoding. When Registering
		the tag, the tagManager also creates a communication channel to do the
		forwarding once the tag is observed.
	*/
	manager := n.connections[destination].sendtags
	// register the tag for this message
	manager.Register(tag)

	// serialize the data into a []byte
	var buf bytes.Buffer

	err := gob.NewEncoder(&buf).Encode(data)
	if err != nil {
		return err
	}

	// special case if sending locally
	if destination == n.myrank {
		n.local.Send(tag, buf.Bytes())
		return nil
	}

	// Launch a reader for the reply message from the destination
	go func() {
		var m message
		err := gob.NewDecoder(n.connections[destination].dial).Decode(&m)
		if err != nil {
			panic(err) // There should never be a send over the connection that isn't a message
		}

		manager.Channel(m.Tag) <- m.Bytes
	}()

	// send the data over the connection.
	enc := gob.NewEncoder(n.connections[destination].dial)
	err = enc.Encode(message{Tag: tag, Bytes: buf.Bytes()})
	if err != nil {
		return err
	}

	// Wait for the confirmation message and then delete the tag
	<-manager.Channel(tag)
	manager.Delete(tag)
	return nil
}
Esempio n. 17
0
func TestPublisherClosesDuplicateConnections(t *testing.T) {
	log.SetOutput(ioutil.Discard)

	// Choose a port
	port, err := getFreePort()
	if err != nil {
		t.Fatal(err)
	}

	// Start a publisher
	p, err := xfer.NewTCPPublisher(port)
	if err != nil {
		t.Fatal(err)
	}
	defer p.Close()

	// Connect a listener
	conn, err := net.Dial("tcp4", "127.0.0.1"+port)
	if err != nil {
		t.Fatal(err)
	}
	defer conn.Close()
	if err := gob.NewEncoder(conn).Encode(xfer.HandshakeRequest{ID: "foo"}); err != nil {
		t.Fatal(err)
	}
	time.Sleep(time.Millisecond)

	// Try to connect the same listener
	dupconn, err := net.Dial("tcp4", "127.0.0.1"+port)
	if err != nil {
		t.Fatal(err)
	}
	// Send handshake
	if err := gob.NewEncoder(dupconn).Encode(xfer.HandshakeRequest{ID: "foo"}); err != nil {
		t.Fatal(err)
	}
	defer dupconn.Close()

	// Publish a message
	p.Publish(report.Report{})

	// The first listener should receive it
	var r report.Report
	if err := gob.NewDecoder(conn).Decode(&r); err != nil {
		t.Fatal(err)
	}

	// The duplicate listener should have an error
	if err := gob.NewDecoder(dupconn).Decode(&r); err == nil {
		t.Errorf("expected error, got none")
	} else {
		t.Logf("dupconn got expected error: %v", err)
	}
}
func main() {
	// generate private key
	privatekey, err := rsa.GenerateKey(rand.Reader, 1024)

	if err != nil {
		fmt.Println(err.Error)
		os.Exit(1)
	}

	var publickey *rsa.PublicKey
	publickey = &privatekey.PublicKey

	// save private and public key separately
	privatekeyfile, err := os.Create("private.key")
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	privatekeyencoder := gob.NewEncoder(privatekeyfile)
	privatekeyencoder.Encode(privatekey)
	privatekeyfile.Close()

	publickeyfile, err := os.Create("public.key")
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	publickeyencoder := gob.NewEncoder(publickeyfile)
	publickeyencoder.Encode(publickey)
	publickeyfile.Close()

	// save PEM file
	pemfile, err := os.Create("private.pem")

	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	// http://golang.org/pkg/encoding/pem/#Block
	var pemkey = &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(privatekey)}

	err = pem.Encode(pemfile, pemkey)

	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	pemfile.Close()
}
Esempio n. 19
0
func (c *Connection) Init() {
	c.send_buffer = new(bytes.Buffer)
	c.recv_buffer = new(bytes.Buffer)
	c.send_buffer_decoder = gob.NewDecoder(c.send_buffer)
	c.send_buffer_encoder = gob.NewEncoder(c.send_buffer)
	c.recv_buffer_decoder = gob.NewDecoder(c.recv_buffer)
	c.recv_buffer_encoder = gob.NewEncoder(c.recv_buffer)

	c.Quit = make(chan bool)
	c.Outgoing = make(chan interface{}, 1000)
}
Esempio n. 20
0
func save(ctx context.Context) {
	stats := stats(ctx)
	stats.wg.Wait()
	stats.Duration = time.Since(stats.Start)

	var buf_part, buf_full bytes.Buffer
	full := stats_full{
		Header: header(ctx),
		Stats:  stats,
	}
	if err := gob.NewEncoder(&buf_full).Encode(&full); err != nil {
		log.Errorf(ctx, "appstats Save error: %v", err)
		return
	} else if buf_full.Len() > bufMaxLen {
		// first try clearing stack traces
		for i := range full.Stats.RPCStats {
			full.Stats.RPCStats[i].StackData = ""
		}
		buf_full.Truncate(0)
		gob.NewEncoder(&buf_full).Encode(&full)
	}
	part := stats_part(*stats)
	for i := range part.RPCStats {
		part.RPCStats[i].StackData = ""
		part.RPCStats[i].In = ""
		part.RPCStats[i].Out = ""
	}
	if err := gob.NewEncoder(&buf_part).Encode(&part); err != nil {
		log.Errorf(ctx, "appstats Save error: %v", err)
		return
	}

	item_part := &memcache.Item{
		Key:   stats.PartKey(),
		Value: buf_part.Bytes(),
	}

	item_full := &memcache.Item{
		Key:   stats.FullKey(),
		Value: buf_full.Bytes(),
	}

	log.Infof(ctx, "Saved; %s: %s, %s: %s, link: %v",
		item_part.Key,
		byteSize(len(item_part.Value)),
		item_full.Key,
		byteSize(len(item_full.Value)),
		URL(ctx),
	)

	nc := storeContext(ctx)
	memcache.SetMulti(nc, []*memcache.Item{item_part, item_full})
}
Esempio n. 21
0
// 参考资料: http://blog.golang.org/gobs-of-data
// gob 似乎是一个Go语言的序列化(反序列化)工具;gob是面向go的,是个非其它语言友好的编码格式,类似于PHP的serialize
func main() {
	data := map[int16]string{1: "first", 2: "second"}
	en := gob.NewEncoder(os.Stdout)
	en.Encode(data)

	fmt.Println()
	var buf bytes.Buffer
	en2 := gob.NewEncoder(&buf)
	en2.Encode(data)
	fmt.Print(buf)

}
Esempio n. 22
0
// Save freezes and saves the data store to disk.
func (ds *DataStore) Save(dsFile string) error {
	if !ds.updated {
		return nil
	}
	logger.Infof("Data has changed, saving data store to disk")
	if dsFile == "" {
		err := fmt.Errorf("Yikes! Cannot save data store to disk because no file was specified.")
		return err
	}
	fp, err := ioutil.TempFile(path.Dir(dsFile), "ds-store")
	if err != nil {
		return err
	}
	zfp := zlib.NewWriter(fp)

	fstore := new(dsFileStore)
	dscache := new(bytes.Buffer)
	objList := new(bytes.Buffer)
	ds.m.RLock()
	defer ds.m.RUnlock()
	ds.updated = false

	err = ds.dsc.Save(dscache)
	if err != nil {
		fp.Close()
		return err
	}
	enc := gob.NewEncoder(objList)
	defer func() {
		if x := recover(); x != nil {
			err = fmt.Errorf("Something went wrong encoding the data store with Gob")
		}
	}()
	err = enc.Encode(ds.objList)
	if err != nil {
		fp.Close()
		return err
	}
	fstore.Cache = dscache.Bytes()
	fstore.ObjList = objList.Bytes()
	enc = gob.NewEncoder(zfp)
	err = enc.Encode(fstore)
	zfp.Close()
	if err != nil {
		fp.Close()
		return err
	}
	err = fp.Close()
	if err != nil {
		return err
	}
	return os.Rename(fp.Name(), dsFile)
}
Esempio n. 23
0
func (d *FileTreeCache) AddEntry(entry protocol.FileInfo, peer protocol.DeviceID) {
	d.db.Update(func(tx *bolt.Tx) error {
		eb := tx.Bucket(d.folderBucketKey).Bucket(entriesBucket)

		/* save entry */
		var buf bytes.Buffer
		enc := gob.NewEncoder(&buf)
		enc.Encode(entry)
		eb.Put([]byte(entry.Name), buf.Bytes()) // TODO handle error?

		/* add peer */
		edb := tx.Bucket(d.folderBucketKey).Bucket(entryDevicesBucket)
		v := edb.Get([]byte(entry.Name))
		var devices map[string]bool
		if v == nil {
			devices = make(map[string]bool)
		} else {
			rbuf := bytes.NewBuffer(v)
			dec := gob.NewDecoder(rbuf)
			dec.Decode(&devices)
		}
		devices[peer.String()] = true
		var dbuf bytes.Buffer
		enc = gob.NewEncoder(&dbuf)
		enc.Encode(devices)
		edb.Put([]byte(entry.Name), dbuf.Bytes())

		/* add child lookup */
		dir := path.Dir(entry.Name)
		clb := tx.Bucket(d.folderBucketKey).Bucket(childLookupBucket)
		v = clb.Get([]byte(dir))
		if debug {
			l.Debugln("Adding child", entry.Name, "for dir", dir)
		}

		var children map[string]bool
		if v == nil {
			children = make(map[string]bool)
		} else {
			rbuf := bytes.NewBuffer(v)
			dec := gob.NewDecoder(rbuf)
			dec.Decode(&children)
		}
		children[entry.Name] = true

		var cbuf bytes.Buffer
		enc = gob.NewEncoder(&cbuf)
		enc.Encode(children)
		clb.Put([]byte(dir), cbuf.Bytes())

		return nil
	})
}
Esempio n. 24
0
func main() {
	var stream bytes.Buffer
	gob.NewEncoder(&stream).Encode(Test{"one", 1})
	var result Test
	dec := gob.NewDecoder(&stream)
	err := dec.Decode(&result)
	log.Print(result, err)
	stream.Reset()
	var result2 Test
	gob.NewEncoder(&stream).Encode(Test{"two", 2})
	err = dec.Decode(&result2)
	log.Print(result2, err)
}
Esempio n. 25
0
// Go should have the same behaviour as net/rpc/Go().
func (r Rrpc) Go(serviceMethod string, args, reply interface{}, done chan *Call) *Call {
	r.mutex.Lock()
	r.nextCallID++
	thisID := r.nextCallID
	r.mutex.Unlock()

	if done == nil {
		done = make(chan *Call, 1)
	} else {
		// Comment from: http://golang.org/src/net/rpc/client.go
		// If caller passes done != nil, it must arrange that
		// done has enough buffer for the number of simultaneous
		// RPCs that will be using that channel.  If the channel
		// is totally unbuffered, it's best not to run at all.
		if cap(done) == 0 {
			log.Panic("rpc: done channel is unbuffered")
		}
	}

	call := &Call{
		Valid:         true,
		ID:            thisID,
		ServiceMethod: serviceMethod,
		replyIface:    reply,
		Done:          done,
	}
	ca := bytes.NewBuffer(call.Args)
	enc := gob.NewEncoder(ca)
	err := enc.Encode(args)
	if err != nil {
		call.ErrorMsg = err.Error()
		call.Error = err
		done <- call
		return call
	}
	call.Args = ca.Bytes()
	cr := bytes.NewBuffer(call.Reply)
	enc2 := gob.NewEncoder(cr)
	err = enc2.Encode(reply)
	if err != nil {
		call.ErrorMsg = err.Error()
		call.Error = err
		done <- call
		return call
	}
	call.Reply = cr.Bytes()
	//fmt.Printf("DEBUG c.waiting <- call Rrpc=%#v Call=%#v\n", r, call)
	r.waiting <- call

	return call
}
Esempio n. 26
0
func (l *commandHolder) getHolderChannel(holderName string) chan command {
	l.Lock()
	defer l.Unlock()
	res, ok := l.channels[holderName]
	if !ok {
		res = commandHolderChannel{cmdChan: make(chan command, 10000), exitChan: make(chan bool)}
		l.channels[holderName] = res
		l.wg.Add(1)
		go func(holderName string, c commandHolderChannel) {
			defer l.wg.Done()

			dir, _ := filepath.Split(holderName)
			os.MkdirAll(dir, os.ModeDir)

			f, err := os.OpenFile(holderName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
			if err != nil {
				panic(err)
			}
			defer f.Close()
			// Сохранение метки начала
			enc := gob.NewEncoder(f)
			startDt := time.Now()
			err = enc.Encode(&startDt)
			if err != nil {
				fmt.Println(err)
			}

			for {
				select {
				case cmd := <-c.cmdChan:
					{
						func() {
							enc := gob.NewEncoder(f)
							err = enc.Encode(&cmd)
							if err != nil {
								fmt.Println(err)
							}

						}()
						l.wgSend.Done()
					}
				case <-c.exitChan:
					{
						return
					}
				}
			}
		}(holderName, res)
	}
	return res.cmdChan
}
Esempio n. 27
0
func (c *Client) encode(typ msgType, val interface{}, dst *net.UDPAddr) error {
	log.ProtoLevel().Tag("client", "discover").Printf("Send request (%v) to %v from %v.", typ, dst, c.conn.LocalAddr())

	reqBuf := bytes.NewBuffer([]byte{})

	buf := make([]byte, binary.MaxVarintLen16)
	binary.PutUvarint(buf, uint64(typ))
	n, err := reqBuf.Write(buf)
	if err != nil {
		return e.Push(err, "error enconding message type")
	}
	if n != len(buf) {
		return e.Push(err, "error enconding message type")
	}

	enc := gob.NewEncoder(reqBuf)
	err = enc.Encode(val)
	if err != nil {
		return e.Push(err, e.New("error encoding"))
	}

	msg, err := NewMsg(c.Name, c.ServerName, c.PrivateKey, c.ServerKey, reqBuf.Bytes())
	if err != nil {
		return e.Push(err, "erro cryptographing the value")
	}

	reqBuf = bytes.NewBuffer([]byte{})
	enc = gob.NewEncoder(reqBuf)
	err = enc.Encode(msg)
	if err != nil {
		return e.Push(err, e.New("error encoding"))
	}

	if reqBuf.Len() > c.BufSize {
		return e.New("value to encode is too big %v", reqBuf.Len())
	}
	err = c.conn.SetDeadline(time.Now().Add(c.Deadline))
	if err != nil {
		return e.New(err)
	}
	_, _, err = c.conn.WriteMsgUDP(reqBuf.Bytes(), nil, dst)
	if err != nil {
		return e.New(err)
	}
	err = c.conn.SetDeadline(time.Time{})
	if err != nil {
		return e.New(err)
	}
	return nil
}
Esempio n. 28
0
File: txn.go Progetto: Crest/gomdb
func (txn *Txn) PutGo(dbi DBI, key, val interface{}, flags uint) error {
	var bkey bytes.Buffer
	encoder := gob.NewEncoder(&bkey)
	err := encoder.Encode(key)
	if err != nil {
		return err
	}
	var bval bytes.Buffer
	encoder = gob.NewEncoder(&bval)
	err = encoder.Encode(val)
	if err != nil {
		return err
	}
	return txn.Put(dbi, bkey.Bytes(), bval.Bytes(), flags)
}
Esempio n. 29
0
func (cursor *Cursor) PutGo(key, val interface{}, flags uint) error {
	var bkey bytes.Buffer
	encoder := gob.NewEncoder(&bkey)
	err := encoder.Encode(key)
	if err != nil {
		return err
	}
	var bval bytes.Buffer
	encoder = gob.NewEncoder(&bval)
	err = encoder.Encode(val)
	if err != nil {
		return err
	}
	return cursor.Put(bkey.Bytes(), bval.Bytes(), flags)
}
Esempio n. 30
0
// Put adds the package documentation to the database.
func (db *Database) Put(pdoc *doc.Package, nextCrawl time.Time) error {
	c := db.Pool.Get()
	defer c.Close()

	score := documentScore(pdoc)
	terms := documentTerms(pdoc, score)

	var gobBuf bytes.Buffer
	if err := gob.NewEncoder(&gobBuf).Encode(pdoc); err != nil {
		return err
	}

	// Truncate large documents.
	if gobBuf.Len() > 700000 {
		pdocNew := *pdoc
		pdoc = &pdocNew
		pdoc.Truncated = true
		pdoc.Vars = nil
		pdoc.Funcs = nil
		pdoc.Types = nil
		pdoc.Consts = nil
		pdoc.Examples = nil
		gobBuf.Reset()
		if err := gob.NewEncoder(&gobBuf).Encode(pdoc); err != nil {
			return err
		}
	}

	gobBytes, err := snappy.Encode(nil, gobBuf.Bytes())
	if err != nil {
		return err
	}

	kind := "p"
	switch {
	case pdoc.Name == "":
		kind = "d"
	case pdoc.IsCmd:
		kind = "c"
	}

	t := int64(0)
	if !nextCrawl.IsZero() {
		t = nextCrawl.Unix()
	}
	_, err = putScript.Do(c, pdoc.ImportPath, pdoc.Synopsis, score, gobBytes, strings.Join(terms, " "), pdoc.Etag, kind, t)
	return err
}