예제 #1
0
파일: main.go 프로젝트: formwork-io/nakker
func bind(socket *zmq.Socket, transport string, address string, port int) {
	endpoint := fmt.Sprintf("%s://%s:%d", transport, address, port)
	err := socket.Bind(endpoint)
	if err != nil {
		die("failed binding %s: %s", endpoint, err.Error())
	}
}
예제 #2
0
파일: server.go 프로젝트: gust1n/zrpc
func sendError(socket *zmq.Socket, req *Request, err error) {
	// Response envelope
	resp := &Response{
		Error: &Response_Error{},
	}

	if req != nil {
		resp.UUID = req.UUID
	}

	// If error is a zrpc error
	if zrpcErr, ok := err.(zrpcError); ok {
		resp.StatusCode = proto.Uint32(uint32(zrpcErr.GetStatusCode()))
		resp.Error.Message = proto.String(zrpcErr.GetMessage())
	} else {
		// Default to internal error
		resp.StatusCode = proto.Uint32(uint32(http.StatusInternalServerError))
		resp.Error.Message = proto.String(err.Error())
	}

	// Encode the response
	buf, protoErr := proto.Marshal(resp)
	if protoErr != nil {
		glog.Error(protoErr)
		return
	}

	// Send the response
	if _, err := socket.SendBytes(buf, 0); err != nil {
		glog.Error(err)
	}
}
예제 #3
0
파일: private.go 프로젝트: xeb/backq
// SendReply will send the reply back to the connected reply proxy
func SendReply(r *http.Response, body string, repsock *zmq.Socket) {
	rep := &messages.Reply{StatusCode: r.StatusCode, Body: body, Headers: r.Header}
	reps := rep.String()
	fmt.Printf("[PRIVATE] sending %d bytes or \n----\n%s\n-----\n", len(reps), reps)
	repsock.Send(reps, 0)
	fmt.Printf("[PRIVATE] sent %d bytes\n", len(reps))
}
예제 #4
0
func r(replier *zmq.Socket) {
	for {
		got, _ := replier.Recv(0)
		log.Println("Received", got)
		replier.Send(`{"jsonrpc":"2.0","id":"youpi","result":{"name":"test","hostname":"localtest","protocol":"test","port":0}}`, 0)
	}
}
예제 #5
0
func receieve(socketrep *zmq.Socket, s Server) {
	var d database
	d.Map = make(map[int]*mydetails)
	go d.statemachinecommit(s)
	for {
		fmt.Println("tcp://127.0.0.1:7001")
		msg, err := socketrep.RecvBytes(0)

		fmt.Println("recived")
		if err != nil {
			fmt.Println(err)
		}
		var req request
		json.Unmarshal(msg, &req)
		fmt.Println("parsing----------------------------------------------------------------------------------------")
		fmt.Println(s.leaderid)
		fmt.Println("parsing")
		fmt.Println(req)
		resp := d.parse(req, s)
		fmt.Println(resp)
		message, _ := json.Marshal(resp)
		socketrep.SendBytes(message, 0)

	}

}
예제 #6
0
func New(id int, f string) Cluster {

	var myid int
	var peer [MAX_SERVER]int
	var cluster [MAX_SERVER]*zmq.Socket
	var mycluster *zmq.Socket
	var no_of_p int
	file, _ := ioutil.ReadFile(f)
	var jsontype jsonobject
	json.Unmarshal(file, &jsontype)
	myid = id
	no_of_p = jsontype.Object.Buffer_size

	for i := 0; i < jsontype.Object.Buffer_size; i++ {
		if jsontype.Object.Peers[i].Id != myid {
			peer[i] = jsontype.Object.Peers[i].Id
			cluster[i], _ = zmq.NewSocket(zmq.PUSH)
			cluster[i].Connect("tcp://" + jsontype.Object.Peers[i].Host)
		} else {
			mycluster, _ = zmq.NewSocket(zmq.PULL)
			mycluster.SetIdentity(string(id))
			a := strings.Split(jsontype.Object.Peers[i].Host, ":")
			mycluster.Bind("tcp://*:" + a[1])
		}
	}

	return Cluster{myid: id, peer: peer, no_of_peer: no_of_p, my_cluster: mycluster, cluster: cluster, inbox: make(chan *Envelope, BUFFER_LENGTH_IN), outbox: make(chan *Envelope, BUFFER_LENGTH_OUT)}
}
예제 #7
0
// This is simple send function here i communicate with raft using simple request-response socket and ask to raft their status
// like phase of raft and we can also close raft server using this function.
// Here msg :- 1 means msg for ask phase of server and msg:- 0 means close the raft server
func send(msg string, requester_C *zmq.Socket) string {

	// Decoding of phse receive by type 0 msg is 0 :- Follower, 1:- Candidate, 2:- Leader
	// By default phase :- "3" means no response from server and server is close
	requester_C.Send(msg, 0)
	phase := "3"
	if msg == "0" {
		return "0"
	}
	phase, _ = requester_C.Recv(0)
	type1 := s.Split(phase, " ")[0]
	value := s.Split(phase, " ")[1]
	if type1 == "-1" {
		if value == "0" {
			phase = "Follower"
		} else if value == "1" {
			phase = "Candidate"
		} else if value == "2" {
			phase = "Leader"
		}
	} else if type1 == "-2" {
		leaderId, _ = strconv.Atoi(value)
	} else if type1 == "0" {
		leaderId, _ = strconv.Atoi(s.Split(phase, " ")[2])
		msg_index, _ := strconv.Atoi(value)
		send(message[msg_index], requester[leaderId-1])
		return "0"
	} else {
	}
	return phase
}
예제 #8
0
func RecMsgFromPeers(s *zmq.Socket, ser Servernode) {
	var e Envelope
	for {
		msg, err := s.RecvMessage(0)
		a1 := strings.Split(msg[0], "&{")
		a2 := strings.Split(a1[1], " ")
		pid, _ := strconv.Atoi(a2[0])
		mid, _ := strconv.Atoi(a2[1])
		msgid := int64(mid)
		text := ""

		for b := 2; b < len(a2); b++ {
			text = text + " " + a2[b]
		}
		text1 := text[1:]
		msgtext := strings.Split(text1, "}")[0]

		e.Pid = pid
		e.MsgId = msgid
		e.Msg = msgtext
		go QueueInbox(ser, e, ser.Inbox())

		if err != nil {
			break
		}
		s.SendMessage(msg)
	}
}
예제 #9
0
func (c *WorkerConnection) run(socket *zmq.Socket) {
	defer socket.Close()
	socket.SetRcvtimeo(c.activeTimeout)
	for {
		select {
		case <-c.quit:
			close(c.wait)
			return
		case request := <-c.requestChannel:
			if _, err := socket.SendMessage(request); err != nil {
				log.Println("Failed to send request:", err)
			}
		case request := <-c.connectionChan:
			go c.handleConnectionRequest(socket, request)
		default:
			message, err := socket.RecvMessageBytes(0)
			if err != nil {
				// Needed to yield to goroutines when GOMAXPROCS is 1.
				// Note: The 1.3 preemptive scheduler doesn't seem to work here,
				// so this is still required.
				runtime.Gosched()
				break
			}
			socket.SetRcvtimeo(c.activeTimeout)
			go c.handleResponse(message)
		}
	}
}
예제 #10
0
파일: binary.go 프로젝트: asokoloski/zproto
// Send sends marshaled data through 0mq socket.
func (b *Binary) Send(socket *zmq.Socket) (err error) {
	frame, err := b.Marshal()
	if err != nil {
		return err
	}

	socType, err := socket.GetType()
	if err != nil {
		return err
	}

	// If we're sending to a ROUTER, we send the routingID first
	if socType == zmq.ROUTER {
		_, err = socket.SendBytes(b.routingID, zmq.SNDMORE)
		if err != nil {
			return err
		}
	}

	// Now send the data frame
	_, err = socket.SendBytes(frame, zmq.SNDMORE)
	if err != nil {
		return err
	}
	// Now send any frame fields, in order
	_, err = socket.SendBytes(b.Address, zmq.SNDMORE)
	_, err = socket.SendBytes(b.Content, 0)

	return err
}
예제 #11
0
파일: kernel.go 프로젝트: go-daw/go-jupyter
func (k *kernelRunner) readMessage(socket *zmq.Socket) (*message, []string, error) {
	parts, err := socket.RecvMessage(0)
	if err != nil {
		return nil, nil, err
	}
	return deserializeMessage(parts, []byte(k.connInfo.Key))
}
예제 #12
0
/****************************************************************
	Receiving Message from all Servers
****************************************************************/
func receiveMessage(recSockets *zmq.Socket, conn *Connection) {

	for {
		select {
		// Stopping Go Routine
		case _, _ = <-conn.stopGoRoutine:

			return

		default:
			recSockets.SetRcvtimeo(500 * time.Millisecond)
			msg, err := recSockets.Recv(0)

			if err == nil {
				msg_array := strings.Split(msg, ":")

				msg_seq := msg_array[0]
				isLeader := msg_array[1]
				leaderId, _ := strconv.Atoi(msg_array[2])

				count, _ := strconv.Atoi(isLeader)

				// Added the LeaderCount if the response belongs to corresponding request
				if strconv.Itoa(conn.attempt) == msg_seq {
					conn.recvCount += 1
					conn.leaders += count

					if leaderId != 0 {
						conn.leaderId = leaderId
					}
				}
			}
		}
	}
}
예제 #13
0
파일: server.go 프로젝트: hintjens/zccp
// Receives marshaled data from 0mq socket.
func recv(socket *zmq.Socket, flag zmq.Flag) (t Transit, err error) {
	// Read all frames
	frames, err := socket.RecvMessageBytes(flag)
	if err != nil {
		return nil, err
	}

	sType, err := socket.GetType()
	if err != nil {
		return nil, err
	}

	var routingId []byte
	// If message came from a router socket, first frame is routingId
	if sType == zmq.ROUTER {
		if len(frames) <= 1 {
			return nil, errors.New("no routingId")
		}
		routingId = frames[0]
		frames = frames[1:]
	}

	t, err = Unmarshal(frames...)
	if err != nil {
		return nil, err
	}

	if sType == zmq.ROUTER {
		t.SetRoutingId(routingId)
	}
	return t, err
}
예제 #14
0
/************************************************************
	Creates Sockets for Sending and Receiving purpose
*************************************************************/
func createSendAndReceivingSocket(configFile string, selfPort int) ([]*zmq.Socket, *zmq.Socket) {

	file, e := ioutil.ReadFile("./" + configFile)

	if e != nil {
		fmt.Printf("Raft Test File error: %v\n", e)
		os.Exit(1)
	}

	var jsontype jsonobject
	json.Unmarshal(file, &jsontype)

	elementCount := len(jsontype.Server)

	sendConnections := make([]*zmq.Socket, elementCount)

	tempId := 0

	for _, value := range jsontype.Server {

		sendConnections[tempId], _ = zmq.NewSocket(zmq.PUSH)
		sendConnections[tempId].Connect("tcp://localhost:" + strconv.Itoa(value.Port_Num+1))
		tempId++
	}

	var receiveConnection *zmq.Socket

	receiveConnection, _ = zmq.NewSocket(zmq.PULL)
	receiveConnection.Bind("tcp://*:" + strconv.Itoa(selfPort))

	return sendConnections, receiveConnection

}
예제 #15
0
// NewEventSubSocketHandler returns a function that handles event notifications
func NewEventSubSocketHandler(eventSubSocket *zmq4.Socket) func(zmq4.State) error {
	var nodeIDMap map[string]uint32
	var err error

	if nodeIDMap, err = centraldb.GetNodeIDMap(); err != nil {
		fog.Critical("centraldb.GetNodeIDMap() failed %s", err)
	}

	return func(_ zmq4.State) error {
		var err error
		var ok bool
		var webWriterStart msg.WebWriterStart
		var timestamp time.Time
		var sourceNodeID uint32

		marshalledMessage, err := eventSubSocket.RecvMessage(0)
		if err != nil {
			return fmt.Errorf("RecvMessage %s", err)
		}

		// the 0th part should be the topic, we skip that

		err = json.Unmarshal([]byte(marshalledMessage[1]), &webWriterStart)
		if err != nil {
			return fmt.Errorf("Unmarshal %s", err)
		}

		if webWriterStart.MessageType != "web-writer-start" {
			return fmt.Errorf("unknown message type '%s'",
				webWriterStart.MessageType)
		}

		timestamp, err = tools.ParseTimestampRepr(webWriterStart.TimestampRepr)
		if err != nil {
			return fmt.Errorf("unable to parse %s %s",
				webWriterStart.TimestampRepr, err)
		}

		sourceNodeID, ok = nodeIDMap[webWriterStart.SourceNodeName]
		if !ok {
			return fmt.Errorf("unknown source_node_name %s",
				webWriterStart.SourceNodeName)
		}

		fog.Debug("cancel-segments-from-node %s", webWriterStart.SourceNodeName)

		// cancel all all segment rows
		//    * from a specifiic source node
		//    * are in active status
		//    * with a timestamp earlier than the specified time.
		// This is triggered by a web server restart
		stmt := nodedb.Stmts["cancel-segments-from-node"]
		if _, err = stmt.Exec(sourceNodeID, timestamp); err != nil {
			return fmt.Errorf("cancel-segments-from-node %s", err)
		}

		return nil
	}
}
예제 #16
0
파일: main.go 프로젝트: iiie/ps1rfid
func openDoor(sp gpio.DirectPinDriver, publisher *zmq.Socket) {
	sp.DigitalWrite(1)
	publisher.SendMessage("door.state.unlock", "Door Unlocked")
	gobot.After(5*time.Second, func() {
		sp.DigitalWrite(0)
		publisher.SendMessage("door.state.lock", "Door Locked")
	})
}
예제 #17
0
파일: bstarsrv2.go 프로젝트: JeremyOT/zmq4
//  Echo service
func echo(socket *zmq.Socket) (err error) {
	msg, err := socket.RecvMessage(0)
	if err != nil {
		return
	}
	_, err = socket.SendMessage(msg)
	return
}
예제 #18
0
// ZmqSendMulti Sends a slice of strings as a multi-part message
func ZmqSendMulti(s *zmq.Socket, msg []string) {
	lastIdx := len(msg) - 1
	for idx, part := range msg {
		if idx == lastIdx {
			s.Send(part, 0)
		} else {
			s.Send(part, zmq.SNDMORE)
		}
	}
}
예제 #19
0
// ZmqRecvMulti Receives a multi-part message and return it as a slice of strings
func ZmqRecvMulti(s *zmq.Socket) []string {
	var msg []string
	more := true
	for more {
		part, _ := s.Recv(0)
		msg = append(msg, part)
		more, _ = s.GetRcvmore()
	}
	return msg
}
예제 #20
0
파일: kernel.go 프로젝트: go-daw/go-jupyter
func (k *kernelRunner) sendMessage(msg *message, ids []string, socket *zmq.Socket) error {
	parts, err := serializeMessage(msg, ids, []byte(k.connInfo.Key))
	if err != nil {
		return fmt.Errorf("serializing message: %v", err)
	}
	if _, err := socket.SendMessage(parts); err != nil {
		return fmt.Errorf("sending message: %v", err)
	}
	return nil
}
예제 #21
0
func applyZMQConfig(socket *zmq.Socket, configs []ZMQConfig) {
	for _, config := range configs {
		switch config.Type {
		case "bind":
			socket.Bind(config.Uri)
		case "connect":
			socket.Connect(config.Uri)
		}
	}
}
func StartZeromqProtobufTest(address string, clients int, requestsPerClient int, messageSize int, timer metrics.Timer, requestSize *int) func(wg *sync.WaitGroup) {
	return func(wg *sync.WaitGroup) {
		var socket *zmq.Socket
		var err error
		var request []byte

		if socket, err = zmq.NewSocket(zmq.REQ); err != nil {
			log.Fatal(err)
		}

		defer socket.Close()
		defer wg.Done()

		if err = socket.Connect("tcp://" + address); err != nil {
			log.Fatal(err)
		}

		if request, err = proto.Marshal(&pb.Request{
			Method:  "TEST",
			Payload: strings.Repeat("a", messageSize),
		}); err != nil {
			log.Fatal(err)
		}

		*requestSize = len(request)

		for i := 0; i < requestsPerClient; i++ {
			timer.Time(func() {
				socket.SendBytes(request, 0)

				socket.Recv(0)
			})
		}
	}
}
/******************************************************************************
* 概述:    订阅退订
* 函数名:    dealCmd
* 返回值:
* 参数列表:  参数名          参数类型      取值范围     描述
*
*******************************************************************************/
func (this *ZmqSocket) dealCmd(cmdSocket *zmq4.Socket) (int, error) {
	log4.Debug("start deal cmd...")
	for { //半包处理
		cmdsStr, err0 := cmdSocket.Recv(zmq4.DONTWAIT)

		if err0 != nil {
			errno1 := zmq4.AsErrno(err0)
			switch errno1 {
			case zmq4.Errno(syscall.EAGAIN):
				return 0, nil
			case zmq4.Errno(syscall.EINTR):
				continue
			default:
				log4.Debug("zmq req Get err %v, %d!", errno1, errno1)
			}
		}
		if len(cmdsStr) == 0 {
			log4.Debug("deal cmd return")
			return 0, nil
		}
		ss := strings.Split(cmdsStr, " ")
		log4.Debug("recv cmd %s", cmdsStr)
		for i := 0; i < len(ss); i++ {
			if len(ss[i]) == 0 {
				continue
			}
			if ss[i] == "stop" {
				//				log4.Debug("recv cmd will stop %s %s", this.mreqUrl, this.msubUrl)
				cmdSocket.Send("0", 0)
				return 1, nil
			}
			if !this.mChoose {
				//				log4.Debug("recv cmd ,but notChoose so return")
				return 0, nil
			}
			if ss[i][0] == 'r' {
				if err := this.msubSocket.SetSubscribe(ss[i][1:]); err != nil {
					log4.Error("SetSubscribe(%s) falied, %s", ss[i][1:], err.Error())
					return 0, err
				}
				log4.Debug("setSubscribe ok %s", ss[i][1:])
				continue
			}
			if ss[i][0] == 'u' {
				if err := this.msubSocket.SetUnsubscribe(ss[i][1:]); err != nil {
					log4.Error("SetUnSubscribe(%s) falied, %s", ss[i][1:], err.Error())
					return 0, err
				}
				log4.Debug("setUnSubscribe ok %s", ss[i][1:])
				continue
			}
		}
	}
	return 0, nil
}
예제 #24
0
파일: rrbroker.go 프로젝트: TomOgoma/GoZMQ
func sendToClient(message string, header []string, title string, more zmq.Flag, frontend *zmq.Socket) {

	//fmt.Println("\t", title)
	for key := range header {
		//fmt.Printf("\tSending to client: %s\n", header[key])
		frontend.Send(header[key], zmq.SNDMORE)
	}
	//fmt.Printf("\tSending to client: %s\n", message)
	frontend.Send(message, more)
	//fmt.Println("\tDone")
}
예제 #25
0
파일: main.go 프로젝트: a-palchikov/kron
func send(socket *zmq.Socket, update keyUpdate) error {
	var err error

	if _, err = socket.Send(update.key, zmq.SNDMORE); err != nil {
		return err
	}
	if _, err = socket.SendBytes(update.payload, 0); err != nil {
		return err
	}
	return nil
}
예제 #26
0
파일: main.go 프로젝트: HackLinux/nimbus.io
// main entry point for data writer
func main() {
	var err error
	var writerSocket *zmq4.Socket
	var eventSubSocket *zmq4.Socket

	fog.Info("program starts")

	if writerSocket, err = createWriterSocket(); err != nil {
		fog.Critical("createWriterSocket %s", err)
	}
	defer writerSocket.Close()

	fog.Info("binding writer socket to %s", dataWriterAddress)
	if err = writerSocket.Bind(dataWriterAddress); err != nil {
		fog.Critical("Bind(%s) %s", dataWriterAddress, err)
	}

	if eventSubSocket, err = createEventSubSocket(); err != nil {
		fog.Critical("createEventSubSocket %s", err)
	}
	defer eventSubSocket.Close()

	fog.Info("connecting event sub socket to %s", eventAggregatorPubAddress)
	if err = eventSubSocket.Connect(eventAggregatorPubAddress); err != nil {
		fog.Critical("Connect(%s) %s", eventAggregatorPubAddress, err)
	}

	messageChan := NewMessageHandler()

	reactor := zmq4.NewReactor()
	reactor.AddChannel(tools.NewSignalWatcher(), 1, tools.SigtermHandler)
	reactor.AddSocket(writerSocket, zmq4.POLLIN,
		NewWriterSocketHandler(writerSocket, messageChan))
	reactor.AddSocket(eventSubSocket, zmq4.POLLIN,
		NewEventSubSocketHandler(eventSubSocket))

	fog.Debug("starting reactor.Run")
	reactor.SetVerbose(true)
	err = reactor.Run(reactorPollingInterval)
	if err == tools.SigtermError {
		fog.Info("program terminates normally due to SIGTERM")
	} else if errno, ok := err.(syscall.Errno); ok {
		// we can get 'interrupted system call' if we get SIGTERM while
		// a socket is waiting on a read. That's not too bad.
		if errno == syscall.EINTR {
			fog.Warn("reactor.Run returns '%s' assuming SIGTERM", errno)
		} else {
			fog.Error("reactor.Run returns %T '%s'", errno, errno)
		}
	} else {
		fog.Error("reactor.Run returns %T %s", err, err)
	}
}
예제 #27
0
파일: client.go 프로젝트: emembrives/remote
func send(requester *zmq.Socket, req *proto.Request) {
	data, err := protobuf.Marshal(req)
	panicOnErr(err)
	requester.SendBytes(data, 0)

	reply, err := requester.RecvBytes(0)
	panicOnErr(err)
	response := new(proto.Response)
	err = protobuf.Unmarshal(reply, response)
	panicOnErr(err)
	fmt.Println("Received ", response.String())
}
예제 #28
0
파일: bstar.go 프로젝트: gallir/zmq4
//  Application wants to speak to us, see if it's possible
func (bstar *Bstar) voter_ready(socket *zmq.Socket) error {
	//  If server can accept input now, call appl handler
	bstar.event = client_REQUEST
	err := bstar.execute_fsm()
	if err == nil {
		bstar.voter_fn(socket)
	} else {
		//  Destroy waiting message, no-one to read it
		socket.RecvMessage(0)
	}
	return nil
}
예제 #29
0
파일: udp_mcast.go 프로젝트: herrfz/gowdc
// args:
// - addr: multicast group/address to listen to
// - port: port number; addr:port builds the mcast socket
// - iface: name of network interface to listen to
// - d_dl_sock:
// - stopch:
func ListenUDPMcast(addr, port, iface string, d_dl_sock *zmq.Socket,
	stopch chan bool) {
	eth, err := net.InterfaceByName(iface)
	if err != nil {
		fmt.Println("Error interface:", err.Error())
		os.Exit(1)
	}

	group := net.ParseIP(addr)
	if group == nil {
		fmt.Println("Error: invalid group address:", addr)
		os.Exit(1)
	}

	// listen to all udp packets on mcast port
	c, err := net.ListenPacket("udp4", "0.0.0.0:"+port)
	if err != nil {
		fmt.Println("Error listening for mcast:", err.Error())
		os.Exit(1)
	}
	// close the listener when the application closes
	defer c.Close()

	// join mcast group
	p := ipv4.NewPacketConn(c)
	if err := p.JoinGroup(eth, &net.UDPAddr{IP: group}); err != nil {
		fmt.Println("Error joining:", err.Error())
		os.Exit(1)
	}
	fmt.Println("Listening on " + addr + ":" + port)

	// enable transmissons of control message
	if err := p.SetControlMessage(ipv4.FlagDst, true); err != nil {
		fmt.Println("Error control message", err.Error())
	}

	c1 := devreader.MakeChannel(UMSocket{p, group})

LOOP:
	for {
		select {
		case v1 := <-c1:
			fmt.Println("received UDP multicast")
			// forward to coord node
			d_dl_sock.Send(string(v1), 0)

		case <-stopch:
			break LOOP
		}

	}
}
예제 #30
0
파일: client.go 프로젝트: hjmat/scrabbled
func initSecurity(private_key_path string, server_key_path string, sock *zmq.Socket) {
	zmq.AuthStart()
	private_key, public_key, err := keyloader.InitKeys(private_key_path)
	condlog.Fatal(err, fmt.Sprintf("Unable to read key pair for private key '%v'", private_key_path))
	zmq.AuthCurveAdd("scrabble", public_key)

	err = keyloader.CheckPermissions(server_key_path)
	condlog.Fatal(err, "Untrustworthy key file")
	server_key_buf, err := ioutil.ReadFile(server_key_path)
	condlog.Fatal(err, fmt.Sprintf("Unable to load public server key '%v'", server_key_path))
	server_key := string(server_key_buf)
	sock.ClientAuthCurve(server_key, public_key, private_key)
}