func newNativeClient(address string, timeout time.Duration, t plugin.PluginType, pub *rsa.PublicKey, secure bool) (*PluginNativeClient, error) {
// Attempt to dial address error on timeout or problem
conn, err := net.DialTimeout("tcp", address, timeout)
// Return nil RPCClient and err if encoutered
if err != nil {
return nil, err
}
r := rpc.NewClient(conn)
p := &PluginNativeClient{
connection: r,
pluginType: t,
timeout: timeout,
}
p.encoder = encoding.NewGobEncoder()
if secure {
key, err := encrypter.GenerateKey()
if err != nil {
return nil, err
}
encrypter := encrypter.New(pub, nil)
encrypter.Key = key
p.encrypter = encrypter
p.encoder.SetEncrypter(encrypter)
}
return p, nil
}
func NewPublisherHttpJSONRPCClient(u string, timeout time.Duration, pub *rsa.PublicKey, secure bool) (PluginPublisherClient, error) {
hjr := &httpJSONRPCClient{
url: u,
timeout: timeout,
pluginType: plugin.PublisherPluginType,
encoder: encoding.NewJsonEncoder(),
}
if secure {
key, err := encrypter.GenerateKey()
if err != nil {
return nil, err
}
e := encrypter.New(pub, nil)
e.Key = key
hjr.encoder.SetEncrypter(e)
hjr.encrypter = e
}
return hjr, nil
}
// NewProcessorGrpcClient returns a processor gRPC Client.
func NewProcessorGrpcClient(address string, timeout time.Duration, pub *rsa.PublicKey, secure bool) (PluginProcessorClient, error) {
address, port, err := parseAddress(address)
if err != nil {
return nil, err
}
p, err := newGrpcClient(address, int(port), timeout, plugin.ProcessorPluginType)
if err != nil {
return nil, err
}
if secure {
key, err := encrypter.GenerateKey()
if err != nil {
return nil, err
}
encrypter := encrypter.New(pub, nil)
encrypter.Key = key
p.encrypter = encrypter
}
return p, nil
}
log "github.com/Sirupsen/logrus"
"github.com/intelsdi-x/snap/control/plugin"
"github.com/intelsdi-x/snap/control/plugin/cpolicy"
"github.com/intelsdi-x/snap/control/plugin/encoding"
"github.com/intelsdi-x/snap/control/plugin/encrypter"
"github.com/intelsdi-x/snap/core"
"github.com/intelsdi-x/snap/core/cdata"
"github.com/intelsdi-x/snap/core/ctypes"
. "github.com/smartystreets/goconvey/convey"
)
var (
key, _ = rsa.GenerateKey(crand.Reader, 1024)
symkey, _ = encrypter.GenerateKey()
)
type mockProxy struct {
e encoding.Encoder
}
func (m *mockProxy) Process(args []byte, reply *[]byte) error {
var dargs plugin.ProcessorArgs
m.e.Decode(args, &dargs)
pr := plugin.ProcessorReply{Content: dargs.Content, ContentType: dargs.ContentType}
*reply, _ = m.e.Encode(pr)
return nil
}
func (m *mockProxy) Publish(args []byte, reply *[]byte) error {
