blob: 2c7853ad1b215c46f8abc17814162aec88ed6a53 [file] [log] [blame]
//package voltha
package main
/*
#include <stdlib.h>
#include "voltha-defs.h"
*/
import "C"
import (
"log"
"golang.org/x/net/context"
"google.golang.org/grpc"
"github.com/golang/protobuf/ptypes/empty"
"github.com/hashicorp/consul/api"
pb "github.com/opencord/voltha/netconf/translator/voltha"
pb_health "github.com/opencord/voltha/netconf/translator/voltha/health"
pb_device "github.com/opencord/voltha/netconf/translator/voltha/device"
pb_adapter "github.com/opencord/voltha/netconf/translator/voltha/adapter"
pb_logical_device "github.com/opencord/voltha/netconf/translator/voltha/logical_device"
pb_openflow "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
pb_any "github.com/golang/protobuf/ptypes/any"
"unsafe"
"fmt"
)
const (
default_consul_address = "10.100.198.220:8500"
default_grpc_address = "localhost:50555"
grpc_service_name = "voltha-grpc"
)
var (
GrpcConn *grpc.ClientConn = nil
VolthaGlobalClient pb.VolthaGlobalServiceClient = nil
HealthClient pb_health.HealthServiceClient = nil
ConsulClient *api.Client = nil
GrpcServiceAddress string = "localhost:50555"
)
func init() {
ConsulClient = connect_to_consul(default_consul_address)
GrpcServiceAddress = get_consul_service_address(grpc_service_name)
GrpcConn = connect_to_grpc(GrpcServiceAddress)
VolthaGlobalClient = pb.NewVolthaGlobalServiceClient(GrpcConn)
HealthClient = pb_health.NewHealthServiceClient(GrpcConn)
}
func connect_to_consul(consul_address string) *api.Client {
cfg := api.Config{Address: consul_address }
log.Printf("Connecting to consul - address: %s", consul_address)
client, err := api.NewClient(&cfg)
if err != nil {
panic(err)
}
log.Printf("Connected to consul - address: %s", consul_address)
return client
}
func get_consul_service_address(service_name string) string {
var service []*api.CatalogService
var err error
log.Printf("Getting consul service - name:%s", service_name)
if service, _, _ = ConsulClient.Catalog().Service(service_name, "", nil); err != nil {
panic(err)
}
address := fmt.Sprintf("%s:%d", service[0].ServiceAddress, service[0].ServicePort)
log.Printf("Got consul service - name:%s, address:%s", service_name, address)
return address
}
func connect_to_grpc(grpc_address string) *grpc.ClientConn {
var err error
var client *grpc.ClientConn
log.Printf("Connecting to grpc - address: %s", grpc_address)
// Set up a connection to the server.
client, err = grpc.Dial(grpc_address, grpc.WithInsecure())
if err != nil {
log.Fatalf("did not connect: %s", err.Error())
}
log.Printf("Connected to grpc - address: %s", grpc_address)
return client
}
// Utility methods
// -------------------------------------------------
// C to Protobuf conversion methods
// -------------------------------------------------
func _c_to_proto_Address(address C.isDevice_Address) *pb_device.Device {
var device *pb_device.Device
// Identify the address type to assign
switch address.Type {
case C.MAC:
device.Address = &pb_device.Device_MacAddress{
MacAddress: C.GoString(address.Value),
}
break
case C.IPV4:
device.Address = &pb_device.Device_Ipv4Address{
Ipv4Address: C.GoString(address.Value),
}
break
case C.IPV6:
device.Address = &pb_device.Device_Ipv6Address{
Ipv6Address: C.GoString(address.Value),
}
break
case C.HOST_AND_PORT:
device.Address = &pb_device.Device_HostAndPort{
HostAndPort: C.GoString(address.Value),
}
break
}
return device
}
// -------------------------------------------------
// Protobuf to C conversion methods
// -------------------------------------------------
func _proto_to_c_Adapters(instances []*pb_adapter.Adapter) C.AdapterArray {
// TODO: not implemented
var result C.AdapterArray
return result
}
func _proto_to_c_LogicalDevices(instances []*pb_logical_device.LogicalDevice) C.LogicalDeviceArray {
// TODO: not implemented
var result C.LogicalDeviceArray
return result
}
func _proto_to_c_DeviceTypes(instances []*pb_device.DeviceType) C.DeviceTypeArray {
// TODO: not implemented
var result C.DeviceTypeArray
return result
}
func _proto_to_c_AlarmFilters(instances []*pb.AlarmFilter) C.AlarmFilterArray {
// TODO: not implemented
var result C.AlarmFilterArray
return result
}
func _proto_to_c_DeviceGroups(instances []*pb.DeviceGroup) C.DeviceGroupArray {
// TODO: not implemented
var result C.DeviceGroupArray
return result
}
func _proto_to_c_ProxyAddress(proxyAddress *pb_device.Device_ProxyAddress) *C.Device_ProxyAddress {
// TODO: not implemented
var result *C.Device_ProxyAddress
defer C.free(unsafe.Pointer(result))
return result
}
func _proto_to_c_Ports(ports []*pb_device.Port) C.PortArray {
// TODO: not implemented
var result C.PortArray
return result
}
func _proto_to_c_Flows(flows *pb_openflow.Flows) *C.Flows {
// TODO: not implemented
var result *C.Flows
defer C.free(unsafe.Pointer(result))
return result
}
func _proto_to_c_FlowGroups(groups *pb_openflow.FlowGroups) *C.FlowGroups {
// TODO: not implemented
var result *C.FlowGroups
defer C.free(unsafe.Pointer(result))
return result
}
func _proto_to_c_PmConfigs(configs *pb_device.PmConfigs) *C.PmConfigs {
// TODO: not implemented
var result *C.PmConfigs
defer C.free(unsafe.Pointer(result))
return result
}
func _proto_to_c_Custom(configs *pb_any.Any) *C.Any {
// TODO: not implemented
var result *C.Any
defer C.free(unsafe.Pointer(result))
return result
}
func _proto_to_c_HealthStatus(health *pb_health.HealthStatus) C.HealthStatus {
var result C.HealthStatus
var c_string *C.char
defer C.free(unsafe.Pointer(c_string))
if c_string = C.CString(health.GetState().String()); c_string != nil {
result.State = c_string
}
return result
}
func _proto_to_c_VolthaInstances(instances []*pb.VolthaInstance) C.VolthaInstanceArray {
var result C.VolthaInstanceArray
var c_string *C.char
var c_voltha_instance C.VolthaInstance
defer C.free(unsafe.Pointer(c_string))
sizeof := unsafe.Sizeof(c_voltha_instance)
count := len(instances)
result.size = C.int(count)
c_items := C.malloc(C.size_t(result.size) * C.size_t(sizeof))
defer C.free(unsafe.Pointer(c_items))
// Array to the allocated space
c_array := (*[1<<30 - 1]C.VolthaInstance)(c_items)
for index, value := range instances {
if c_string = C.CString(value.GetInstanceId()); c_string != nil {
c_voltha_instance.InstanceId = c_string
}
if c_string = C.CString(value.GetVersion()); c_string != nil {
c_voltha_instance.Version = c_string
}
if c_string = C.CString(value.GetLogLevel().String()); c_string != nil {
c_voltha_instance.LogLevel = c_string
}
c_voltha_instance.Health = _proto_to_c_HealthStatus(value.GetHealth())
c_voltha_instance.Adapters = _proto_to_c_Adapters(value.GetAdapters())
c_voltha_instance.LogicalDevices = _proto_to_c_LogicalDevices(value.GetLogicalDevices())
c_voltha_instance.Devices = _proto_to_c_Devices(value.GetDevices())
c_voltha_instance.DeviceTypes = _proto_to_c_DeviceTypes(value.GetDeviceTypes())
c_voltha_instance.DeviceGroups = _proto_to_c_DeviceGroups(value.GetDeviceGroups())
c_voltha_instance.AlarmFilters = _proto_to_c_AlarmFilters(value.GetAlarmFilters())
c_array[index] = c_voltha_instance
}
result.items = (*C.VolthaInstance)(unsafe.Pointer(c_array))
return result
}
func _proto_to_c_Devices(instances []*pb_device.Device) C.DeviceArray {
var result C.DeviceArray
var c_string *C.char
var c_device_instance C.Device
defer C.free(unsafe.Pointer(c_string))
sizeof := unsafe.Sizeof(c_device_instance)
count := len(instances)
result.size = C.int(count)
c_items := C.malloc(C.size_t(result.size) * C.size_t(sizeof))
defer C.free(unsafe.Pointer(c_items))
c_array := (*[1<<30 - 1]C.Device)(c_items)
for index, value := range instances {
c_array[index] = _proto_to_c_Device(value)
}
result.items = (*C.Device)(unsafe.Pointer(c_array))
return result
}
func _proto_to_c_Voltha(voltha *pb.Voltha) C.Voltha {
var result C.Voltha
var c_string *C.char
defer C.free(unsafe.Pointer(c_string))
if c_string = C.CString(voltha.GetVersion()); c_string != nil {
result.Version = c_string
}
if c_string = C.CString(voltha.GetLogLevel().String()); c_string != nil {
result.LogLevel = c_string
}
result.Instances = _proto_to_c_VolthaInstances(voltha.GetInstances())
result.Adapters = _proto_to_c_Adapters(voltha.GetAdapters())
result.LogicalDevices = _proto_to_c_LogicalDevices(voltha.GetLogicalDevices())
result.Devices = _proto_to_c_Devices(voltha.GetDevices())
result.DeviceGroups = _proto_to_c_DeviceGroups(voltha.GetDeviceGroups())
return result
}
func _proto_to_c_Address(device *pb_device.Device) C.isDevice_Address {
var address C.isDevice_Address
var c_string *C.char
defer C.free(unsafe.Pointer(c_string))
switch device.GetAddress().(type) {
case *pb_device.Device_MacAddress:
address.Type = C.MAC
c_string = C.CString(device.GetMacAddress())
address.Value = c_string
case *pb_device.Device_Ipv4Address:
address.Type = C.IPV4
c_string = C.CString(device.GetIpv4Address())
address.Value = c_string
case *pb_device.Device_Ipv6Address:
address.Type = C.IPV6
c_string = C.CString(device.GetIpv6Address())
address.Value = c_string
case *pb_device.Device_HostAndPort:
address.Type = C.HOST_AND_PORT
c_string = C.CString(device.GetHostAndPort())
address.Value = c_string
}
return address
}
func _proto_to_c_Device(device *pb_device.Device) C.Device {
var result C.Device
var c_string *C.char
defer C.free(unsafe.Pointer(c_string))
if c_string = C.CString(device.GetId()); c_string != nil {
result.Id = c_string
}
if c_string = C.CString(device.GetType()); c_string != nil {
result.Type = c_string
}
if device.GetRoot() {
result.Root = C.int(1)
} else {
result.Root = C.int(0)
}
if c_string = C.CString(device.GetParentId()); c_string != nil {
result.ParentId = c_string
}
result.ParentPortNo = C.uint32_t(device.GetParentPortNo())
if c_string = C.CString(device.GetVendor()); c_string != nil {
result.Vendor = c_string
}
if c_string = C.CString(device.GetModel()); c_string != nil {
result.Model = c_string
}
if c_string = C.CString(device.GetHardwareVersion()); c_string != nil {
result.HardwareVersion = c_string
}
if c_string = C.CString(device.GetFirmwareVersion()); c_string != nil {
result.FirmwareVersion = c_string
}
if c_string = C.CString(device.GetSoftwareVersion()); c_string != nil {
result.SoftwareVersion = c_string
}
if c_string = C.CString(device.GetSerialNumber()); c_string != nil {
result.SerialNumber = c_string
}
if c_string = C.CString(device.GetAdapter()); c_string != nil {
result.Adapter = c_string
}
result.Vlan = C.uint32_t(device.GetVlan())
result.ProxyAddress = _proto_to_c_ProxyAddress(device.GetProxyAddress())
if c_string = C.CString(device.GetAdminState().String()); c_string != nil {
result.AdminState = c_string
}
if c_string = C.CString(device.GetOperStatus().String()); c_string != nil {
result.OperStatus = c_string
}
if c_string = C.CString(device.GetReason()); c_string != nil {
result.Reason = c_string
}
if c_string = C.CString(device.GetConnectStatus().String()); c_string != nil {
result.ConnectStatus = c_string
}
result.Custom = _proto_to_c_Custom(device.GetCustom())
result.Ports = _proto_to_c_Ports(device.GetPorts())
result.Flows = _proto_to_c_Flows(device.GetFlows())
result.FlowGroups = _proto_to_c_FlowGroups(device.GetFlowGroups())
result.PmConfigs = _proto_to_c_PmConfigs(device.GetPmConfigs())
result.Address = _proto_to_c_Address(device)
return result
}
// ---------------------------------------------------------
// Exported methods accessible through the shared library
// ---------------------------------------------------------
//export GetHealthStatus
func GetHealthStatus() C.HealthStatus {
var output *pb_health.HealthStatus
var err error
if output, err = HealthClient.GetHealthStatus(context.Background(), &empty.Empty{}); output == nil || err != nil {
log.Fatalf("Failed to retrieve health status: %s", err.Error())
}
return _proto_to_c_HealthStatus(output)
}
//export GetVoltha
func GetVoltha() C.Voltha {
var output *pb.Voltha
var err error
if output, err = VolthaGlobalClient.GetVoltha(context.Background(), &empty.Empty{}); output == nil || err != nil {
log.Fatalf("Failed to retrieve voltha information: %s", err.Error())
}
return _proto_to_c_Voltha(output)
}
//export ListDevices
func ListDevices() C.DeviceArray {
var output *pb_device.Devices
var err error
if output, err = VolthaGlobalClient.ListDevices(context.Background(), &empty.Empty{});
output == nil || err != nil {
log.Fatalf("Failed to retrieve voltha information: %s", err.Error())
}
return _proto_to_c_Devices(output.Items)
}
//export ListVolthaInstances
func ListVolthaInstances() *C.char {
return nil
}
//export ListLogicalDevices
func ListLogicalDevices() *C.char {
return nil
}
//export GetLogicalDevice
func GetLogicalDevice(input *C.char) *C.char {
return nil
}
//export ListLogicalDevicePorts
func ListLogicalDevicePorts(input *C.char) *C.char {
return nil
}
//export ListLogicalDeviceFlows
func ListLogicalDeviceFlows(input *C.char) *C.char {
return nil
}
//export CreateDevice
func CreateDevice(input C.Device) C.Device {
log.Printf("Incoming C Device - type:%v, address_type: %v, address_value:%s",
C.GoString(input.Type),
C.int(input.Address.Type),
C.GoString(input.Address.Value),
)
device := _c_to_proto_Address(input.Address)
device.Type = C.GoString(input.Type)
var output *pb_device.Device
var err error
if output, err = VolthaGlobalClient.CreateDevice(context.Background(), device);
output == nil || err != nil {
log.Fatalf("Failed to create device: %s", err.Error())
}
return _proto_to_c_Device(output)
}
// Debugging code
func TestSerialize() {
var object C.Device
object.Type = C.CString("simulated_olt")
object.Address.Type = 3
object.Address.Value = C.CString("172.16.1.233:123")
//xmlObject, _ := xml.Marshal(object)
//
//log.Printf("object: %+v", string(xmlObject))
CreateDevice(object)
}
func main() {
// We need the main function to make possible
// CGO compiler to compile the package as C shared library
//TestSerialize()
}