func (s *NetworkSuite) TestPortRangeConvenience(c *gc.C) {
networkPortRange := network.PortRange{
FromPort: 61001,
ToPort: 61010,
Protocol: "tcp",
}
paramsPortRange := params.FromNetworkPortRange(networkPortRange)
networkPortRangeBack := paramsPortRange.NetworkPortRange()
c.Assert(networkPortRange, jc.DeepEquals, networkPortRangeBack)
}
// GetMachinePorts returns the port ranges opened on a machine for the specified
// subnet as a map mapping port ranges to the tags of the units that opened
// them.
func (f *FirewallerAPI) GetMachinePorts(args params.MachinePortsParams) (params.MachinePortsResults, error) {
result := params.MachinePortsResults{
Results: make([]params.MachinePortsResult, len(args.Params)),
}
canAccess, err := f.accessMachine()
if err != nil {
return params.MachinePortsResults{}, err
}
for i, param := range args.Params {
machineTag, err := names.ParseMachineTag(param.MachineTag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
var subnetTag names.SubnetTag
if param.SubnetTag != "" {
subnetTag, err = names.ParseSubnetTag(param.SubnetTag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
}
machine, err := f.getMachine(canAccess, machineTag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
ports, err := machine.OpenedPorts(subnetTag.Id())
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if ports != nil {
portRangeMap := ports.AllPortRanges()
var portRanges []network.PortRange
for portRange := range portRangeMap {
portRanges = append(portRanges, portRange)
}
network.SortPortRanges(portRanges)
for _, portRange := range portRanges {
unitTag := names.NewUnitTag(portRangeMap[portRange]).String()
result.Results[i].Ports = append(result.Results[i].Ports,
params.MachinePortRange{
UnitTag: unitTag,
PortRange: params.FromNetworkPortRange(portRange),
})
}
}
}
return result, nil
}
func (u *UniterAPIV1) getOneMachinePorts(canAccess common.AuthFunc, machineTag string) params.MachinePortsResult {
tag, err := names.ParseMachineTag(machineTag)
if err != nil {
return params.MachinePortsResult{Error: common.ServerError(common.ErrPerm)}
}
if !canAccess(tag) {
return params.MachinePortsResult{Error: common.ServerError(common.ErrPerm)}
}
machine, err := u.getMachine(tag)
if err != nil {
return params.MachinePortsResult{Error: common.ServerError(err)}
}
allPorts, err := machine.AllPorts()
if err != nil {
return params.MachinePortsResult{Error: common.ServerError(err)}
}
var resultPorts []params.MachinePortRange
for _, ports := range allPorts {
// AllPortRanges gives a map, but apis require a stable order
// for results, so sort the port ranges.
portRangesToUnits := ports.AllPortRanges()
portRanges := make([]network.PortRange, 0, len(portRangesToUnits))
for portRange := range portRangesToUnits {
portRanges = append(portRanges, portRange)
}
network.SortPortRanges(portRanges)
for _, portRange := range portRanges {
unitName := portRangesToUnits[portRange]
resultPorts = append(resultPorts, params.MachinePortRange{
UnitTag: names.NewUnitTag(unitName).String(),
PortRange: params.FromNetworkPortRange(portRange),
})
}
}
return params.MachinePortsResult{
Ports: resultPorts,
}
}