How to use org.apache.cloudstack.network

private boolean isNetscalerDevice(String deviceName) {
  if ((deviceName == null) || ((!deviceName.equalsIgnoreCase(NetworkDevice.NetscalerMPXLoadBalancer.getName()))
      && (!deviceName.equalsIgnoreCase(NetworkDevice.NetscalerSDXLoadBalancer.getName()))
      && (!deviceName.equalsIgnoreCase(NetworkDevice.NetscalerVPXLoadBalancer.getName())))) {
    return false;
  } else {
    return true;
  }
}

@Override
public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException,
  ResourceAllocationException {
  try {
    Host device = nwDeviceMgr.addNetworkDevice(this);
    NetworkDeviceResponse response = nwDeviceMgr.getApiResponse(device);
    response.setObjectName("networkdevice");
    response.setResponseName(getCommandName());
    this.setResponseObject(response);
  } catch (InvalidParameterValueException ipve) {
    throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ipve.getMessage());
  } catch (CloudRuntimeException cre) {
    throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, cre.getMessage());
  }
}

@Override
public List<Host> listExternalLoadBalancers(long physicalNetworkId, String deviceName) {
  List<Host> lbHosts = new ArrayList<Host>();
  NetworkDevice lbNetworkDevice = NetworkDevice.getNetworkDevice(deviceName);
  PhysicalNetworkVO pNetwork = null;
  pNetwork = _physicalNetworkDao.findById(physicalNetworkId);
  if ((pNetwork == null) || (lbNetworkDevice == null)) {
    throw new InvalidParameterValueException("Atleast one of the required parameter physical networkId, device name is invalid.");
  }
  PhysicalNetworkServiceProviderVO ntwkSvcProvider =
    _physicalNetworkServiceProviderDao.findByServiceProvider(pNetwork.getId(), lbNetworkDevice.getNetworkServiceProvder());
  // if provider not configured in to physical network, then there can be no instances
  if (ntwkSvcProvider == null) {
    return null;
  }
  List<ExternalLoadBalancerDeviceVO> lbDevices =
    _externalLoadBalancerDeviceDao.listByPhysicalNetworkAndProvider(physicalNetworkId, ntwkSvcProvider.getProviderName());
  for (ExternalLoadBalancerDeviceVO provderInstance : lbDevices) {
    lbHosts.add(_hostDao.findById(provderInstance.getHostId()));
  }
  return lbHosts;
}

@Override
public OpenDaylightControllerVO addController(AddOpenDaylightControllerCmd cmd) {
  ServerResource odlController = new OpenDaylightControllerResource();
  final String deviceName = NetworkDevice.OpenDaylightController.getName();
  NetworkDevice networkDevice = NetworkDevice.getNetworkDevice(deviceName);
  if (networkDevice == null) {
    throw new CloudRuntimeException("No network device found for name " + deviceName);
  final Long physicalNetworkId = cmd.getPhysicalNetworkId();
  PhysicalNetworkVO physicalNetwork = physicalNetworkDao.findById(physicalNetworkId);
  if (physicalNetwork == null) {
      networkDevice.getNetworkServiceProvder());
  if (ntwkSvcProvider == null) {
    throw new CloudRuntimeException("Network Service Provider: " + networkDevice.getNetworkServiceProvder() + " is not enabled in the physical network: "
        + physicalNetworkId + "to add this device");
  } else if (ntwkSvcProvider.getState() == PhysicalNetworkServiceProvider.State.Shutdown) {
  hostParams.put("physicalNetworkId", String.valueOf(physicalNetwork.getId()));
  hostParams.put("name", "ODL Controller - " + hostParams.get("guid"));
  hostParams.put("url", cmd.getUrl());
  hostParams.put("username", cmd.getUsername());
  hostParams.put("password", cmd.getPassword());

  @Override
  public ExternalLoadBalancerDeviceVO doInTransaction(TransactionStatus status) {
    ExternalLoadBalancerDeviceVO lbDeviceVO =
      new ExternalLoadBalancerDeviceVO(host.getId(), pNetworkFinal.getId(), ntwkDevice.getNetworkServiceProvder(), deviceName, capacityFinal,
        dedicatedUse, gslbProvider);
    if (gslbProvider) {
      lbDeviceVO.setGslbSitePublicIP(gslbSitePublicIp);
      lbDeviceVO.setGslbSitePrivateIP(gslbSitePrivateIp);
      lbDeviceVO.setExclusiveGslbProvider(exclusiveGslbProivider);
    }
    _externalLoadBalancerDeviceDao.persist(lbDeviceVO);
    DetailVO hostDetail = new DetailVO(host.getId(), ApiConstants.LOAD_BALANCER_DEVICE_ID, String.valueOf(lbDeviceVO.getId()));
    _hostDetailDao.persist(hostDetail);
    return lbDeviceVO;
  }
});

@Override
public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException,
  ResourceAllocationException {
  try {
    List<Host> devices = nwDeviceMgr.listNetworkDevice(this);
    List<NetworkDeviceResponse> nwdeviceResponses = new ArrayList<NetworkDeviceResponse>();
    ListResponse<NetworkDeviceResponse> listResponse = new ListResponse<NetworkDeviceResponse>();
    for (Host d : devices) {
      NetworkDeviceResponse response = nwDeviceMgr.getApiResponse(d);
      response.setObjectName("networkdevice");
      response.setResponseName(getCommandName());
      nwdeviceResponses.add(response);
    }
    listResponse.setResponses(nwdeviceResponses);
    listResponse.setResponseName(getCommandName());
    this.setResponseObject(listResponse);
  } catch (InvalidParameterValueException ipve) {
    throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ipve.getMessage());
  } catch (CloudRuntimeException cre) {
    throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, cre.getMessage());
  }
}

@Override
public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException,
  ResourceAllocationException {
  try {
    boolean result = nwDeviceMgr.deleteNetworkDevice(this);
    if (result) {
      SuccessResponse response = new SuccessResponse(getCommandName());
      response.setResponseName(getCommandName());
      this.setResponseObject(response);
    } else {
      throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to delete network device:" + getId());
    }
  } catch (InvalidParameterValueException ipve) {
    throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ipve.getMessage());
  } catch (CloudRuntimeException cre) {
    throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, cre.getMessage());
  }
}

@Override
public List<Host> listExternalFirewalls(long physicalNetworkId, String deviceName) {
  List<Host> firewallHosts = new ArrayList<Host>();
  NetworkDevice fwNetworkDevice = NetworkDevice.getNetworkDevice(deviceName);
  PhysicalNetworkVO pNetwork = null;
  pNetwork = _physicalNetworkDao.findById(physicalNetworkId);
  if (pNetwork == null) {
    throw new InvalidParameterValueException("Could not find phyical network with ID: " + physicalNetworkId);
  }
  if ((pNetwork == null) || (fwNetworkDevice == null)) {
    throw new InvalidParameterValueException("Atleast one of ther required parameter physical networkId, device name is missing or invalid.");
  }
  PhysicalNetworkServiceProviderVO ntwkSvcProvider =
    _physicalNetworkServiceProviderDao.findByServiceProvider(pNetwork.getId(), fwNetworkDevice.getNetworkServiceProvder());
  if (ntwkSvcProvider == null) {
    return null;
  }
  List<ExternalFirewallDeviceVO> fwDevices = _externalFirewallDeviceDao.listByPhysicalNetworkAndProvider(physicalNetworkId, ntwkSvcProvider.getProviderName());
  for (ExternalFirewallDeviceVO fwDevice : fwDevices) {
    firewallHosts.add(_hostDao.findById(fwDevice.getHostId()));
  }
  return firewallHosts;
}

  public static NetworkDevice getNetworkDevice(String devicerName) {
    for (NetworkDevice device : supportedNetworkDevices) {
      if (device.getName().equalsIgnoreCase(devicerName)) {
        return device;
      }
    }
    return null;
  }
}

String guid;
PhysicalNetworkVO pNetwork = null;
NetworkDevice ntwkDevice = NetworkDevice.getNetworkDevice(deviceName);
long zoneId;
  _physicalNetworkServiceProviderDao.findByServiceProvider(pNetwork.getId(), ntwkDevice.getNetworkServiceProvder());
if (ntwkSvcProvider == null) {
  throw new CloudRuntimeException("Network Service Provider: " + ntwkDevice.getNetworkServiceProvder() + " is not enabled in the physical network: " +
    physicalNetworkId + "to add this device");
} else if (ntwkSvcProvider.getState() == PhysicalNetworkServiceProvider.State.Shutdown) {

public ExternalLoadBalancerDeviceVO(long hostId, long physicalNetworkId, String providerName, String deviceName, long capacity, boolean dedicated,
    boolean gslbProvider) {
  this.physicalNetworkId = physicalNetworkId;
  this.providerName = providerName;
  this.deviceName = deviceName;
  this.hostId = hostId;
  this.state = LBDeviceState.Disabled;
  this.allocationState = LBDeviceAllocationState.Free;
  this.capacity = capacity;
  this.isDedicatedDevice = dedicated;
  this.isManagedDevice = false;
  this.state = LBDeviceState.Enabled;
  this.uuid = UUID.randomUUID().toString();
  this.gslbProvider = gslbProvider;
  this.gslbSitePublicIP = null;
  this.gslbSitePrivateIP = null;
  if (deviceName.equalsIgnoreCase(ExternalNetworkDeviceManager.NetworkDevice.NetscalerSDXLoadBalancer.getName())) {
    this.allocationState = LBDeviceAllocationState.Provider;
  }
}

ServerResource resource = new BrocadeVcsResource();
final String deviceName = Network.Provider.BrocadeVcs.getName();
NetworkDevice networkDevice = NetworkDevice.getNetworkDevice(deviceName);
if (networkDevice == null) {
  throw new CloudRuntimeException("No network device found for " + deviceName);
    networkDevice.getNetworkServiceProvder());
if (ntwkSvcProvider == null) {
  throw new CloudRuntimeException("Network Service Provider: " + networkDevice.getNetworkServiceProvder() + " is not enabled in the physical network: "
      + physicalNetworkId + "to add this device");
} else if (ntwkSvcProvider.getState() == PhysicalNetworkServiceProvider.State.Shutdown) {

@Override
public boolean deletePaloAltoFirewall(DeletePaloAltoFirewallCmd cmd) {
  Long fwDeviceId = cmd.getFirewallDeviceId();
  ExternalFirewallDeviceVO fwDeviceVO = _fwDevicesDao.findById(fwDeviceId);
  if (fwDeviceVO == null || !fwDeviceVO.getDeviceName().equalsIgnoreCase(NetworkDevice.PaloAltoFirewall.getName())) {
    throw new InvalidParameterValueException("No Palo Alto firewall device found with ID: " + fwDeviceId);
  }
  return deleteExternalFirewall(fwDeviceVO.getHostId());
}

ServerResource resource = new NiciraNvpResource();
final String deviceName = Network.Provider.NiciraNvp.getName();
NetworkDevice networkDevice = NetworkDevice.getNetworkDevice(deviceName);
if (networkDevice == null) {
  throw new CloudRuntimeException("No network device found for " + deviceName);
    physicalNetworkServiceProviderDao.findByServiceProvider(physicalNetwork.getId(), networkDevice.getNetworkServiceProvder());
if (ntwkSvcProvider == null) {
  throw new CloudRuntimeException("Network Service Provider: " + networkDevice.getNetworkServiceProvder() + " is not enabled in the physical network: " +
      physicalNetworkId + "to add this device");
} else if (ntwkSvcProvider.getState() == PhysicalNetworkServiceProvider.State.Shutdown) {

Collection paramsCollection = paramList.values();
HashMap params = (HashMap)(paramsCollection.toArray())[0];
if (NetworkDevice.ExternalDhcp.getName().equalsIgnoreCase(cmd.getDeviceType())) {
  Long zoneId = Long.parseLong((String)params.get(ApiConstants.ZONE_ID));
  Long podId = Long.parseLong((String)params.get(ApiConstants.POD_ID));
  res = listNetworkDevice(zoneId, null, podId, Host.Type.ExternalDhcp);
} else if (NetworkDevice.PxeServer.getName().equalsIgnoreCase(cmd.getDeviceType())) {
  Long zoneId = Long.parseLong((String)params.get(ApiConstants.ZONE_ID));
  Long podId = Long.parseLong((String)params.get(ApiConstants.POD_ID));

@Override
public ExternalFirewallDeviceVO addPaloAltoFirewall(AddPaloAltoFirewallCmd cmd) {
  String deviceName = cmd.getDeviceType();
  if (!deviceName.equalsIgnoreCase(NetworkDevice.PaloAltoFirewall.getName())) {
    throw new InvalidParameterValueException("Invalid Palo Alto firewall device type");
  }
  return addExternalFirewall(cmd.getPhysicalNetworkId(), cmd.getUrl(), cmd.getUsername(), cmd.getPassword(), deviceName, new PaloAltoResource());
}

@Override
public List<? extends Network> listNetworks(ListPaloAltoFirewallNetworksCmd cmd) {
  Long fwDeviceId = cmd.getFirewallDeviceId();
  List<NetworkVO> networks = new ArrayList<NetworkVO>();
  ExternalFirewallDeviceVO fwDeviceVo = _fwDevicesDao.findById(fwDeviceId);
  if (fwDeviceVo == null || !fwDeviceVo.getDeviceName().equalsIgnoreCase(NetworkDevice.PaloAltoFirewall.getName())) {
    throw new InvalidParameterValueException("Could not find Palo Alto firewall device with ID " + fwDeviceId);
  }
  List<NetworkExternalFirewallVO> networkFirewallMaps = _networkFirewallDao.listByFirewallDeviceId(fwDeviceId);
  if (networkFirewallMaps != null && !networkFirewallMaps.isEmpty()) {
    for (NetworkExternalFirewallVO networkFirewallMap : networkFirewallMaps) {
      NetworkVO network = _networkDao.findById(networkFirewallMap.getNetworkId());
      networks.add(network);
    }
  }
  return networks;
}

@Override
public ExternalFirewallDeviceVO configurePaloAltoFirewall(ConfigurePaloAltoFirewallCmd cmd) {
  Long fwDeviceId = cmd.getFirewallDeviceId();
  Long deviceCapacity = cmd.getFirewallCapacity();
  ExternalFirewallDeviceVO fwDeviceVO = _fwDevicesDao.findById(fwDeviceId);
  if (fwDeviceVO == null || !fwDeviceVO.getDeviceName().equalsIgnoreCase(NetworkDevice.PaloAltoFirewall.getName())) {
    throw new InvalidParameterValueException("No Palo Alto firewall device found with ID: " + fwDeviceId);
  }
  if (deviceCapacity != null) {
    // check if any networks are using this Palo Alto device
    List<NetworkExternalFirewallVO> networks = _networkFirewallDao.listByFirewallDeviceId(fwDeviceId);
    if ((networks != null) && !networks.isEmpty()) {
      if (deviceCapacity < networks.size()) {
        throw new CloudRuntimeException("There are more number of networks already using this Palo Alto firewall device than configured capacity");
      }
    }
    if (deviceCapacity != null) {
      fwDeviceVO.setCapacity(deviceCapacity);
    }
  }
  fwDeviceVO.setDeviceState(FirewallDeviceState.Enabled);
  _fwDevicesDao.update(fwDeviceId, fwDeviceVO);
  return fwDeviceVO;
}

@Override
public List<ExternalFirewallDeviceVO> listPaloAltoFirewalls(ListPaloAltoFirewallsCmd cmd) {
  Long physcialNetworkId = cmd.getPhysicalNetworkId();
  Long fwDeviceId = cmd.getFirewallDeviceId();
  PhysicalNetworkVO pNetwork = null;
  List<ExternalFirewallDeviceVO> fwDevices = new ArrayList<ExternalFirewallDeviceVO>();
  if (physcialNetworkId == null && fwDeviceId == null) {
    throw new InvalidParameterValueException("Either physical network Id or load balancer device Id must be specified");
  }
  if (fwDeviceId != null) {
    ExternalFirewallDeviceVO fwDeviceVo = _fwDevicesDao.findById(fwDeviceId);
    if (fwDeviceVo == null || !fwDeviceVo.getDeviceName().equalsIgnoreCase(NetworkDevice.PaloAltoFirewall.getName())) {
      throw new InvalidParameterValueException("Could not find Palo Alto firewall device with ID: " + fwDeviceId);
    }
    fwDevices.add(fwDeviceVo);
  }
  if (physcialNetworkId != null) {
    pNetwork = _physicalNetworkDao.findById(physcialNetworkId);
    if (pNetwork == null) {
      throw new InvalidParameterValueException("Could not find phyical network with ID: " + physcialNetworkId);
    }
    fwDevices = _fwDevicesDao.listByPhysicalNetworkAndProvider(physcialNetworkId, Provider.PaloAlto.getName());
  }
  return fwDevices;
}

? Boolean.parseBoolean(configParams.get(ApiConstants.LOAD_BALANCER_DEVICE_DEDICATED)) : false;
if (dedicatedUse && !deviceName.equals(NetworkDevice.NetscalerVPXLoadBalancer.getName())) {
  String msg = "Only Netscaler VPX load balancers can be specified for dedicated use";
  s_logger.debug(msg);
  if (!deviceName.equals(NetworkDevice.NetscalerVPXLoadBalancer.getName())
      && !deviceName.equals(NetworkDevice.NetscalerMPXLoadBalancer.getName())) {
    String msg = "Only Netscaler VPX or MPX load balancers can be specified as GSLB service provider";
    s_logger.debug(msg);