netopeer/voltha-netconf-model/netconf-model.go

/*
 * Copyright 2017-present Open Networking Foundation

 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at

 * http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
//package netconf-model
package main

/*
#include <stdlib.h>
#include <voltha-defs.h>
*/
import "C"

import (
	"log"
	"encoding/xml"
	"unsafe"
)

func init() {
}

// ----------------------------------------------
// Data structures
// ----------------------------------------------

type Adapter struct {
}

type Adapters struct {
	XMLName xml.Name `xml:"adapters"`
	Items   []Adapter
}

type LogicalDevice struct {
}

type LogicalDevices struct {
	XMLName xml.Name `xml:"logical_devices"`
	Items   []LogicalDevice
}

type DeviceGroup struct {
}

type DeviceGroups struct {
	XMLName xml.Name `xml:"device_groups"`
	Items   []Device
}

type DeviceType struct {
}

type DeviceTypes struct {
	XMLName xml.Name `xml:"device_types"`
	Items   []DeviceType
}

type AlarmFilter struct {
}

type AlarmFilters struct {
	XMLName xml.Name `xml:"alarm_filters"`
	Items   []AlarmFilter
}

type Custom struct {
}

type ProxyAddress struct {
}

type Port struct {
}

type Ports struct {
	XMLName xml.Name `xml:"ports"`
	Items   []Port
}

type Flow struct {
}

type Flows struct {
	XMLName xml.Name `xml:"flows"`
	Items   []Flow
}

type FlowGroup struct {
}

type FlowGroups struct {
	XMLName xml.Name `xml:"flow_groups"`
	Items   []FlowGroup
}

type PmConfig struct {
}

type PmConfigs struct {
	XMLName xml.Name `xml:"pm_configs"`
	Items   []PmConfig
}

type Address struct {
	MacAddress  string `xml:"mac_address,omitempty"`
	Ipv4Address string `xml:"ipv4_address,omitempty"`
	Ipv6Address string `xml:"ipv6_address,omitempty"`
	HostAndPort string `xml:"host_and_port,omitempty"`
}
type Device struct {
	XMLName         xml.Name `xml:"device"`
	Id              string `xml:"id"`
	Type            string `xml:"type"`
	Root            int `xml:"root"`
	ParentId        string `xml:"parent_id"`
	ParentPortNo    int `xml:"parent_port_no"`
	Vendor          string `xml:"vendor"`
	Model           string `xml:"model"`
	HardwareVersion string `xml:"hardware_version"`
	FirmwareVersion string `xml:"firmware_version"`
	SoftwareVersion string `xml:"software_version"`
	Adapter         string `xml:"adapter"`
	Vlan            int `xml:"vlan"`
	ProxyAddress    ProxyAddress `xml:"proxy_address"`
	AdminState      string `xml:"admin_state"`
	OperStatus      string `xml:"oper_status"`
	Reason          string `xml:"reason"`
	ConnectStatus   string `xml:"connect_status"`
	Custom          Custom `xml:"custom"`
	Ports           Ports `xml:"ports"`
	Flows           Flows `xml:"flows"`
	FlowGroups      FlowGroups `xml:"flow_groups"`
	PmConfigs       PmConfigs `xml:"pm_configs"`
	Address
}
type Devices struct {
	XMLName xml.Name `xml:"devices"`
	Items   []Device
}

type HealthStatus struct {
	XMLName xml.Name `xml:"health"`
	State   string `xml:"state"`
}
type Voltha struct {
	XMLName        xml.Name `xml:"voltha"`
	Version        string `xml:"version"`
	LogLevel       string `xml:"log_level"`
	Instances      VolthaInstances `xml:"instances"`
	Adapters       Adapters `xml:"adapters"`
	LogicalDevices LogicalDevices `xml:"logical_devices"`
	Devices        Devices `xml:"devices"`
	DeviceGroups   DeviceGroups `xml:"device_groups"`
}
type VolthaInstance struct {
	XMLName        xml.Name `xml:"voltha_instance"`
	InstanceId     string `xml:"instance_id"`
	Version        string `xml:"version"`
	LogLevel       string `xml:"log_level"`
	HealthStatus   string `xml:"health"`
	Adapters       Adapters `xml:"adapters"`
	LogicalDevices LogicalDevices `xml:"logical_devices"`
	Devices        Devices `xml:"devices"`
	DeviceTypes    DeviceTypes `xml:"device_types"`
	DeviceGroups   DeviceGroups `xml:"device_groups"`
	AlarmFilters   AlarmFilters `xml:"alarm_filters"`
}
type VolthaInstances struct {
	Items []VolthaInstance `xml:"items"`
}

// ----------------------------------------------
// Conversion utility methods
// ----------------------------------------------

func _constructVolthaInstances(instances C.VolthaInstanceArray) VolthaInstances {
	var v VolthaInstances
	var item VolthaInstance
	var c_instance C.VolthaInstance

	length := instances.size
	c_instances := (*[1 << 30]C.VolthaInstance)(unsafe.Pointer(instances.items))[:length:length]

	for i := 0; i < int(instances.size); i += 1 {
		c_instance = c_instances[i]
		item.InstanceId = C.GoString(c_instance.InstanceId)
		item.Version = C.GoString(c_instance.Version)
		item.LogLevel = C.GoString(c_instance.LogLevel)
		//item.HealthStatus = C.GoString(c_instance.Health)
		item.Adapters = _constructAdapters(c_instance.Adapters)
		item.LogicalDevices = _constructLogicalDevices(c_instance.LogicalDevices)
		item.Devices = _constructDevices(c_instance.Devices)
		item.DeviceTypes = _constructDeviceTypes(c_instance.DeviceTypes)
		item.DeviceGroups = _constructDeviceGroups(c_instance.DeviceGroups)
		item.AlarmFilters = _constructAlarmFilters(c_instance.AlarmFilters)

		v.Items = append(v.Items, item)
	}

	return v
}
func _constructAdapters(instances C.AdapterArray) Adapters {
	return Adapters{}
}
func _constructLogicalDevices(instances C.LogicalDeviceArray) LogicalDevices {
	return LogicalDevices{}
}
func _constructDevices(instances C.DeviceArray) Devices {
	var d Devices
	var item Device
	var c_instance C.Device

	length := instances.size
	log.Printf("number of instances : %d", length)
	c_instances := (*[1 << 30]C.Device)(unsafe.Pointer(instances.items))[:length:length]

	for i := 0; i < int(instances.size); i += 1 {
		c_instance = c_instances[i]

		item = _constructDevice(c_instance)

		d.Items = append(d.Items, item)
	}

	return d
}
func _constructDeviceGroups(instances C.DeviceGroupArray) DeviceGroups {
	return DeviceGroups{}
}
func _constructDeviceTypes(instances C.DeviceTypeArray) DeviceTypes {
	return DeviceTypes{}
}
func _constructAlarmFilters(instances C.AlarmFilterArray) AlarmFilters {
	return AlarmFilters{}
}
func _constructVoltha(voltha C.Voltha) Voltha {
	return Voltha{
		Version:        C.GoString(voltha.Version),
		LogLevel:       C.GoString(voltha.LogLevel),
		Instances:      _constructVolthaInstances(voltha.Instances),
		Adapters:       _constructAdapters(voltha.Adapters),
		LogicalDevices: _constructLogicalDevices(voltha.LogicalDevices),
		Devices:        _constructDevices(voltha.Devices),
		DeviceGroups:   _constructDeviceGroups(voltha.DeviceGroups),
	}
}
func _constructProxyAddress(proxyAddress *C.Device_ProxyAddress) ProxyAddress {
	return ProxyAddress{}
}
func _constructPorts(ports C.PortArray) Ports {
	return Ports{}
}
func _constructFlows(flows *C.Flows) Flows {
	return Flows{}
}
func _constructFlowGroups(flowGroups *C.FlowGroups) FlowGroups {
	return FlowGroups{}
}
func _constructPmConfigs(pmConfigs *C.PmConfigs) PmConfigs {
	return PmConfigs{}
}
func _constructAddress(address C.isDevice_Address) Address {
	var a Address
	switch address.Type {
	case C.MAC:
		a.MacAddress = C.GoString(address.Value)
	case C.IPV4:
		a.Ipv4Address = C.GoString(address.Value)
	case C.IPV6:
		a.Ipv6Address = C.GoString(address.Value)
	case C.HOST_AND_PORT:
		a.HostAndPort = C.GoString(address.Value)
	}
	return a
}

func _constructDevice(device C.Device) Device {
	d := Device{
		Id:              C.GoString(device.Id),
		Type:            C.GoString(device.Type),
		Root:            int(device.Root),
		ParentId:        C.GoString(device.ParentId),
		ParentPortNo:    int(device.ParentPortNo),
		Vendor:          C.GoString(device.Vendor),
		Model:           C.GoString(device.Model),
		HardwareVersion: C.GoString(device.HardwareVersion),
		FirmwareVersion: C.GoString(device.FirmwareVersion),
		SoftwareVersion: C.GoString(device.SoftwareVersion),
		Adapter:         C.GoString(device.Adapter),
		Vlan:            int(device.Vlan),
		ProxyAddress:    _constructProxyAddress(device.ProxyAddress),
		AdminState:      C.GoString(device.AdminState),
		OperStatus:      C.GoString(device.OperStatus),
		Reason:          C.GoString(device.Reason),
		ConnectStatus:   C.GoString(device.ConnectStatus),
		Ports:           _constructPorts(device.Ports),
		Flows:           _constructFlows(device.Flows),
		FlowGroups:      _constructFlowGroups(device.FlowGroups),
		PmConfigs:       _constructPmConfigs(device.PmConfigs),
		Address:         _constructAddress(device.Address),
	}

	return d
}

func _constructHealthStatus(health C.HealthStatus) HealthStatus {
	return HealthStatus{
		State: C.GoString(health.State),
	}
}

// ----------------------------------------------
// Exported translation methods
// ----------------------------------------------

//export TranslateVoltha
func TranslateVoltha(voltha C.Voltha) *C.char {
	var err error
	var data []byte
	var cs *C.char;
	defer C.free(unsafe.Pointer(cs))

	v := _constructVoltha(voltha)

	if data, err = xml.Marshal(v); err != nil {
		log.Printf("ERROR While marshalling: %s", err.Error())
	}

	cs = C.CString(string(data))

	return cs
}

//export TranslateDevice
func TranslateDevice(device C.Device) *C.char {
	var err error
	var data []byte
	var cs *C.char;
	defer C.free(unsafe.Pointer(cs))

	d := _constructDevice(device)

	if data, err = xml.Marshal(d); err != nil {
		log.Printf("ERROR While marshalling: %s", err.Error())
	}

	cs = C.CString(string(data))

	return cs
}

//export TranslateDevices
func TranslateDevices(devices C.DeviceArray) *C.char {
	var err error
	var data []byte
	var cs *C.char;
	defer C.free(unsafe.Pointer(cs))

	d := _constructDevices(devices)

	if data, err = xml.Marshal(d); err != nil {
		log.Printf("ERROR While marshalling: %s", err.Error())
	}

	cs = C.CString(string(data))

	return cs
}

//export TranslateHealthStatus
func TranslateHealthStatus(health C.HealthStatus) *C.char {
	var err error
	var data []byte
	var cs *C.char;
	defer C.free(unsafe.Pointer(cs))

	d := _constructHealthStatus(health)

	if data, err = xml.Marshal(d); err != nil {
		log.Printf("ERROR While marshalling: %s", err.Error())
	}

	cs = C.CString(string(data))

	return cs
}

func main() {
	// We need the main function to make possible
	// CGO compiler to compile the package as C shared library
}