Kite Micro-service Framework

To write a new kite, follow these steps:

1. Import the github.com/koding/kite package.
2. Create a new instance using kite.New(name, version).
3. Register method handlers using k.HandleFunc(name, handler) or k.Handle(name, handler).
4. Configure the server (e.g., setting k.Config.Port) and call k.Run().

package main

import "github.com/koding/kite"

func main() {
	// Create a kite
	k := kite.New("math", "1.0.0")

	// Add our handler method with the name "square"
	k.HandleFunc("square", func(r *kite.Request) (interface{}, error) {
		a := r.Args.One().MustFloat64()
		result := a * a    // calculate the square
		return result, nil // send back the result
	}).DisableAuthentication()

	// Attach to a server with port 3636 and run it
	k.Config.Port = 3636
	k.Run()
}

To use Kite in your Go project, install the package using go get and import it using the package name kite.

go get github.com/koding/kite

import "github.com/koding/kite"

Kontrol is the service registry and authentication service for Kites. To set it up:

1. Install the Kontrol package: go get github.com/koding/kite/kontrol/kontrol

2. Generate RSA keys for authentication:

   openssl genrsa -out key.pem 2048
   openssl rsa -in key.pem -pubout > key_pub.pem

3. Set the following environment variables:

   • KONTROL_PORT: Port for Kontrol (e.g., 6000)
   • KONTROL_USERNAME: Username for the service
   • KONTROL_STORAGE: Storage backend (e.g., etcd)
   • KONTROL_KONTROLURL: The URL of the Kontrol service
   • KONTROL_PUBLICKEYFILE: Path to the public key
   • KONTROL_PRIVATEKEYFILE: Path to the private key

4. Initialize Kontrol: ./bin/kontrol -initial

To communicate with a running kite, create a client instance using k.NewClient(url), establish the connection with Dial(), and invoke methods using Tell(methodName, args...).

package main

import (
	"fmt"

	"github.com/koding/kite"
)

func main() {
	k := kite.New("exp2", "1.0.0")

	// Connect to our math kite
	mathWorker := k.NewClient("http://localhost:3636/kite")
	mathWorker.Dial()

	response, _ := mathWorker.Tell("square", 4) // call "square" method with argument 4
	fmt.Println("result:", response.MustFloat64())
}

To authenticate with a remote Kite that requires credentials, set the Auth field on the Client. The Auth struct supports the following types:

• kiteKey (uses the Key field)
• token (uses the Key field)
• sessionID (uses the Key field)

The Client allows fine-tuning how messages are processed:

• Concurrent (bool): If true (default), incoming messages are processed in separate goroutines. If false, they are processed sequentially.
• ConcurrentCallbacks (bool): If true, execution of callbacks in incoming messages is concurrent. Note that this means no order is guaranteed for callback execution.

When querying Kontrol for service discovery, the query path follows this structure:

/<username>/<environment>/<name>/<version>/<region>/<hostname>/<id>

Requirements:

• You must provide at least the username.
• Fields are ordered from general to specific.
• Empty parts between fields are not allowed.

The Port() method returns the TCP port number the Kite is listening on.

Note: This method must be called after the listener has been initialized. Because Run() is blocking, you should run it in a goroutine and use ServerReadyNotify() to wait for the listener to be ready before calling Port().

k := kite.New("x", "1.0.0")
go k.Run()
<-k.ServerReadyNotify()
port := k.Port()

To create a client for communicating with a remote Kite, use the NewClient method on an existing *Kite instance. The returned *Client is not connected immediately; you must call Dial(), DialTimeout(), or DialForever() to establish a connection.

Note that if Config is not provided to the client, it will default to the configuration of the LocalKite used to create it.