import org.opendaylight.alto.commons.helper.Converter;
import org.opendaylight.alto.commons.types.model150404.ModelDstCosts;
-public class RFC2ModelCostMapDataConverter
+public class RFC2ModelCostMapDataConverter
extends Converter<Map<String, Object>, List<ModelDstCosts>> {
-
+
public RFC2ModelCostMapDataConverter() {
}
public RFC2ModelCostMapDataConverter(Map<String, Object> _in) {
super(_in);
}
-
+
@Override
protected Object _convert() {
List<ModelDstCosts> dstCostsList = new LinkedList<ModelDstCosts>();
--- /dev/null
+package org.opendaylight.alto.commons.types.converter;
+
+import org.opendaylight.alto.commons.helper.Converter;
+
+import org.opendaylight.alto.commons.types.rfc7285.RFC7285CostMap;
+import org.opendaylight.alto.commons.types.rfc7285.RFC7285VersionTag;
+import org.opendaylight.alto.commons.types.rfc7285.RFC7285Endpoint;
+import org.opendaylight.alto.commons.types.rfc7285.RFC7285CostType;
+
+import java.util.Map;
+import java.util.LinkedHashMap;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.databind.JsonNode;
+
+public class YANGJSON2RFCCostMapConverter extends Converter<JsonNode, RFC7285CostMap> {
+ public YANGJSON2RFCCostMapConverter() {
+ }
+
+ public YANGJSON2RFCCostMapConverter(JsonNode _in) {
+ super(_in);
+ }
+
+ protected YANGJSON2RFCAddressGroupConverter group_converter
+ = new YANGJSON2RFCAddressGroupConverter();
+
+ @Override
+ protected Object _convert() {
+ JsonNode node = this.in();
+ RFC7285CostMap cm = new RFC7285CostMap();
+
+ JsonNode meta = node.get("meta");
+ for (JsonNode vtag: meta.get("dependentVtags")) {
+ String resource_id = vtag.get("resourceId").get("value").asText();
+ String tag = vtag.get("tag").get("value").asText();
+ cm.meta.netmap_tags.add(new RFC7285VersionTag(resource_id, tag));
+ }
+
+ JsonNode cost_type = meta.get("costType");
+ String mode = cost_type.get("costMode").asText();
+ String metric = cost_type.get("costMetric").get("value").asText();
+ cm.meta.costType = new RFC7285CostType(mode, metric);
+
+ JsonNode map = node.get("map");
+ assert !map.isArray();
+ for (JsonNode cost_map: map) {
+ String src_pid = cost_map.get("src").get("value").asText();
+ Map<String, Object> data = new LinkedHashMap<String, Object>();
+
+ for (JsonNode dst: cost_map.get("dstCosts")) {
+ String dst_pid = dst.get("dst").get("value").asText();
+ //TODO Don't know how to get data...
+
+ data.put(dst_pid, new Integer(1));
+ }
+
+ cm.map.put(src_pid, data);
+ }
+ return cm;
+ }
+}
@JsonProperty("alto-service:resource-id")
public String rid = null;
-
+
@JsonProperty("alto-service:tag")
public String tag = null;
-
+
@JsonProperty("alto-service:meta")
public ModelCostMapMeta meta = null;
-
+
@JsonProperty("alto-service:map")
public List<ModelCostMapData> map = new LinkedList<ModelCostMapData>();
-
+
@JsonIgnore
@Override
public Class<? extends DataContainer> getImplementedInterface() {
@JsonProperty("alto-service:dst")
public String dst = null;
-
+
@JsonProperty("alto-service:cost")
public Object cost = null;
-
+
@JsonIgnore
@Override
public Class<? extends DataContainer> getImplementedInterface() {
import java.util.List;
import java.util.Map;
+import java.util.LinkedList;
import java.util.LinkedHashMap;
import com.fasterxml.jackson.annotation.JsonProperty;
public static class Meta extends Extensible {
@JsonProperty("dependent-vtags")
- public List<RFC7285VersionTag> netmap_tags;
+ public List<RFC7285VersionTag> netmap_tags = new LinkedList<RFC7285VersionTag>();
@JsonProperty("cost-type")
public RFC7285CostType costType;
}
@JsonProperty("meta")
- public Meta meta;
+ public Meta meta = new Meta();
@JsonProperty("cost-map")
public Map<String, Map<String, Object>> map
public class RFC7285QueryPairs {
@JsonProperty("srcs")
- List<String> src = new LinkedList<String>();
+ public List<String> src = new LinkedList<String>();
@JsonProperty("dsts")
- List<String> dst = new LinkedList<String>();
+ public List<String> dst = new LinkedList<String>();
}
private RFC2ModelCostMapConverter costMapConverter = new RFC2ModelCostMapConverter();
private RFC2ModelEndpointPropMapConverter endpointPropConverter = new RFC2ModelEndpointPropMapConverter();
private MAP_FORMAT_TYPE format = MAP_FORMAT_TYPE.RFC;
-
+
@Argument(index = 0, name = "resource-type", description = "Resource Type", required = true, multiValued = false)
String resourceType = null;
@Argument(index = 1, name = "resource-file", description = "Resource File", required = true, multiValued = false)
String resourceFile = null;
-
+
public AltoCreate() {
super();
}
-
+
@Override
protected Object doExecute() throws Exception {
if (networkMapType().equals(resourceType)) {
}
return null;
}
-
+
private void putNetworkMaps() throws Exception {
log.info("Loading network maps from " + this.resourceFile);
List<ModelNetworkMap> networkMaps = getYangNetworkMaps(readFromFile(resourceFile));
putMap(AltoManagerConstants.NETWORK_MAP_URL, map.rid, data);
}
}
-
+
private List<ModelNetworkMap> getYangNetworkMaps(String data) throws Exception {
if (MAP_FORMAT_TYPE.RFC.equals(format)) {
List<ModelNetworkMap> modelNetworkMaps = new ArrayList<ModelNetworkMap>();
}
return modelMapper.asNetworkMapList(data);
}
-
+
private void putCostMaps() throws Exception {
log.info("Loading cost map from " + this.resourceFile);
List<ModelCostMap> costMaps = getYangCostMaps(readFromFile(resourceFile));
putMap(AltoManagerConstants.COST_MAP_URL, map.rid, data);
}
}
-
+
private List<ModelCostMap> getYangCostMaps(String data) throws Exception {
if (MAP_FORMAT_TYPE.RFC.equals(format)) {
List<ModelCostMap> modelCostMaps = new ArrayList<ModelCostMap>();
}
return modelMapper.asCostMapList(data);
}
-
+
private void putEndpointPropertyMap() throws Exception {
log.info("Loading endpoint property map from " + this.resourceFile);
ModelEndpointPropertyMap endpointPropMap = getYangEndpointPropMap(readFromFile(resourceFile));
String data = modelMapper.asJSON(endpointPropMap);
httpPut(AltoManagerConstants.ENDPOINT_PROP_MAP_URL, wrapdata(data));
}
-
+
private ModelEndpointPropertyMap getYangEndpointPropMap(String data) throws Exception {
if (MAP_FORMAT_TYPE.RFC.equals(format)) {
return endpointPropConverter.convert(rfcMapper.asEndpointPropMap(data));
}
return modelMapper.asEndpointPropMap(data);
}
-
+
private void putMap(String baseUrl, String resourceId, String data) throws Exception {
if (resourceId == null) {
throw new RuntimeException("No ResourceId Specified.");
}
httpPut(baseUrl + resourceId, wrapdata(data));
}
-
+
private String wrapdata(String data) throws Exception {
if (endpointPropertyMapType().equals(resourceType)) {
return "{\"alto-service:" + resourceType + "\":" + data + "}";
public class AltoManager extends OsgiCommandSupport {
private static final Logger log = LoggerFactory.getLogger(AltoManager.class);
-
+
protected HttpClient httpClient;
public AltoManager () {
new UsernamePasswordCredentials("admin:admin"));
return HttpClientBuilder.create().setDefaultCredentialsProvider(credentialsProvider).build();
}
-
+
@Override
protected Object doExecute() throws Exception {
return null;
return new String(Files.readAllBytes(Paths.get(path)),
StandardCharsets.UTF_8);
}
-
+
protected boolean isDefaultNetworkMap(String resourceId) throws IOException {
String defaultNetworkResourceId = getDefaultNetworMapResourceId();
return (defaultNetworkResourceId != null) && defaultNetworkResourceId.equals(resourceId);
}
-
+
protected String getDefaultNetworMapResourceId() throws IOException {
HttpResponse response = httpGet(AltoManagerConstants.IRD_DEFAULT_NETWORK_MAP_URL);
Pattern pattern = Pattern.compile(AltoManagerConstants.DEFAULT_NETWORK_MAP_REGEX);
Matcher matcher = pattern.matcher(EntityUtils.toString(response.getEntity()));
return matcher.find() ? matcher.group(1) : null;
}
-
+
protected HttpResponse httpGet(String url) throws IOException {
HttpGet httpGet = new HttpGet(url);
logHttpRequest("HTTP GET:", url, "");
httpGet.setHeader(HTTP.CONTENT_TYPE, AltoManagerConstants.JSON_CONTENT_TYPE);
return httpClient.execute(httpGet);
}
-
+
protected boolean httpPut(String url, String data) throws IOException {
HttpPut httpPut = new HttpPut(url);
httpPut.setHeader(HTTP.CONTENT_TYPE, AltoManagerConstants.JSON_CONTENT_TYPE);
HttpResponse response = httpClient.execute(httpPut);
return handleResponse(response);
}
-
+
protected boolean httpDelete(String url) throws IOException {
HttpDelete httpDelete = new HttpDelete(url);
httpDelete.setHeader(HTTP.CONTENT_TYPE, AltoManagerConstants.JSON_CONTENT_TYPE);
HttpResponse response = httpClient.execute(httpDelete);
return handleResponse(response);
}
-
+
private void logHttpRequest(String prefix, String url, String data) {
- log.debug(prefix +
- "\nUrl: " + url +
+ log.debug(prefix +
+ "\nUrl: " + url +
"\nHeader: " + HTTP.CONTENT_TYPE + ": " + AltoManagerConstants.JSON_CONTENT_TYPE +
"\nData: " + data);
}
-
+
protected boolean handleResponse(HttpResponse response) throws ParseException, IOException {
int statusCode = response.getStatusLine().getStatusCode();
logResponse(response);
return false;
}
}
-
+
protected void logResponse(HttpResponse response) throws IOException {
HttpEntity entity = response.getEntity();
int statusCode = response.getStatusLine().getStatusCode();
+ "\nStatus Code: " + statusCode
+ "\nBody: " + body);
}
-
+
protected String networkMapType() {
return AltoManagerConstants.SERVICE_TYPE.NETWORK_MAP.toString()
.toLowerCase().replace("_", "-");
}
-
+
protected String costMapType() {
return AltoManagerConstants.SERVICE_TYPE.COST_MAP.toString()
.toLowerCase().replace("_", "-");
}
-
+
protected String endpointPropertyMapType() {
return AltoManagerConstants.SERVICE_TYPE.ENDPOINT_PROPERTY_MAP.toString()
.toLowerCase().replace("_", "-");
public static final String HOST = "http://127.0.0.1:8181/restconf/config/";
public static final String MODULE = "alto-service";
public static final String JSON_CONTENT_TYPE = "application/yang.data+json";
-
+
public static final String RESOURCES_NODE = MODULE + ":resources";
public static final String IRD_NODE = MODULE + ":IRD";
public static final String META_NODE = MODULE + ":meta";
public static final String DEFAULT_NETWORK_MAP_NODE = MODULE + ":default-alto-network-map";
-
+
public static final String NETWORK_MAPS_NODE = MODULE + ":network-maps";
public static final String NETWORK_MAP_NODE = MODULE + ":network-map";
public static final String COST_MAPS_NODE = MODULE + ":cost-maps";
public static final String COST_MAP_URL = RESOURCES_URL + COST_MAPS_NODE + "/" + COST_MAP_NODE + "/";
public static final String ENDPOINT_PROP_MAP_URL = RESOURCES_URL + ENDPOINT_PROPERTY_MAP_NODE;
public static final String IRD_DEFAULT_NETWORK_MAP_URL = RESOURCES_URL + IRD_NODE + "/" + META_NODE + "/" + DEFAULT_NETWORK_MAP_NODE + "/";
-
+
public static final String DEFAULT_NETWORK_MAP_PROPERTY = "default-network-map";
public static final String DELIMETER = "-";
-
+
public static final String DEFAULT_NETWORK_MAP_REGEX = "^\\{\"default-alto-network-map\":\\{\"resource-id\":\"(.*)\"\\}}$";
-
+
public static enum COST_MODE {
Numerical, Ordinal
}
-
+
public static enum SERVICE_TYPE{
NETWORK_MAP, COST_MAP, ENDPOINT_PROPERTY_MAP
}
-
+
public static enum MAP_FORMAT_TYPE {
YANG, RFC
}
-}
\ No newline at end of file
+}
public class CostMetricBuilder {
public static CostMetric getDefaultInstance(java.lang.String defaultValue) {
- throw new java.lang.UnsupportedOperationException("Not yet implemented");
+ return new CostMetric(defaultValue);
}
}
package org.opendaylight.alto.services.provider.simple;
import org.opendaylight.alto.services.api.rfc7285.NetworkMapService;
+import org.opendaylight.alto.services.api.rfc7285.CostMapService;
+
import org.opendaylight.alto.commons.types.rfc7285.RFC7285NetworkMap;
import org.opendaylight.alto.commons.types.rfc7285.RFC7285Endpoint;
import org.opendaylight.alto.commons.types.rfc7285.RFC7285VersionTag;
+import org.opendaylight.alto.commons.types.rfc7285.RFC7285CostMap;
+import org.opendaylight.alto.commons.types.rfc7285.RFC7285VersionTag;
+import org.opendaylight.alto.commons.types.rfc7285.RFC7285CostType;
+
import org.opendaylight.alto.commons.types.converter.YANGJSON2RFCNetworkMapConverter;
+import org.opendaylight.alto.commons.types.converter.YANGJSON2RFCCostMapConverter;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.Resources;
import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.resources.IRD;
import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.resources.NetworkMaps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.resources.CostMaps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.resources.cost.maps.CostMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.resources.cost.maps.CostMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.resources.network.maps.NetworkMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.rev150404.resources.network.maps.NetworkMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.alto.service.types.rev150404.ResourceId;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Map;
import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.LinkedList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
-public class SimpleAltoService implements NetworkMapService, AutoCloseable {
+public class SimpleAltoService implements NetworkMapService, CostMapService, AutoCloseable {
private final Logger m_logger = LoggerFactory.getLogger(SimpleAltoService.class);
private DataBroker m_db = null;
private ObjectMapper m_mapper = new ObjectMapper();
- private ServiceRegistration m_reg = null;
- private YANGJSON2RFCNetworkMapConverter m_converter = null;
+ private List<ServiceRegistration> m_reg = new LinkedList<ServiceRegistration>();
+ private YANGJSON2RFCNetworkMapConverter m_nmconverter = null;
+ private YANGJSON2RFCCostMapConverter m_cmconverter = null;
public SimpleAltoService(DataBroker db) {
this.m_db = db;
- this.m_reg = ServiceHelper.registerGlobalServiceWReg(NetworkMapService.class, this, null);
- this.m_converter = new YANGJSON2RFCNetworkMapConverter();
- assert ServiceHelper.getGlobalInstance(NetworkMapService.class, this) != this;
+ this.m_nmconverter = new YANGJSON2RFCNetworkMapConverter();
+ this.m_cmconverter = new YANGJSON2RFCCostMapConverter();
+
+ this.register(NetworkMapService.class);
+ this.register(CostMapService.class);
+ }
+
+ protected <E> void register(Class<E> clazz) {
+ ServiceRegistration reg = ServiceHelper.registerGlobalServiceWReg(clazz, this, null);
+ if (reg != null)
+ this.m_reg.add(reg);
+
+ assert ServiceHelper.getGlobalInstance(clazz, this) != this;
}
@Override
public void close() {
- this.m_reg.unregister();
+ for (ServiceRegistration reg: this.m_reg) {
+ reg.unregister();
+ }
+ this.m_reg.clear();
}
@Override
try {
ReadOnlyTransaction tx = m_db.newReadOnlyTransaction();
ListenableFuture<Optional<NetworkMap>> result
- = tx.read(LogicalDatastoreType.CONFIGURATION, niid);
+ = tx.read(LogicalDatastoreType.CONFIGURATION, niid);
if (result.get().isPresent()) {
NetworkMap nm = result.get().get();
ObjectNode node = m_mapper.valueToTree(nm);
m_logger.info(m_mapper.writeValueAsString(nm));
- RFC7285NetworkMap ret = m_converter.convert(node);
+ RFC7285NetworkMap ret = m_nmconverter.convert(node);
return ret;
} else {
m_logger.info("Failed to read with niid: {}", niid);
return validateNetworkMapFilter(vtag.rid, filter);
}
+ @Override
+ public RFC7285CostMap getCostMap(String id) {
+ m_logger.info("Handling cost-map resource: {}", id);
+ InstanceIdentifier<CostMap> ciid = getCostMapIID(id);
+ m_logger.info("CostMap IID: {}", ciid);
+
+ try {
+ ReadOnlyTransaction tx = m_db.newReadOnlyTransaction();
+ ListenableFuture<Optional<CostMap>> result
+ = tx.read(LogicalDatastoreType.CONFIGURATION, ciid);
+ if (result.get().isPresent()) {
+ CostMap cm = result.get().get();
+ m_logger.info(m_mapper.writeValueAsString(cm));
+ ObjectNode node = m_mapper.valueToTree(cm);
+
+ RFC7285CostMap ret = m_cmconverter.convert(node);
+ return ret;
+ } else {
+ m_logger.info("Failed to read with ciid: {}", ciid);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public RFC7285CostMap getCostMap(RFC7285VersionTag vtag) {
+ //TODO
+ return null;
+ }
+
+ @Override
+ public RFC7285CostMap getCostMap(String id, RFC7285CostType type) {
+ RFC7285CostMap cm = getCostMap(id);
+ if (cm == null)
+ return null;
+ if (!type.equals(cm.meta.costType))
+ return null;
+ return cm;
+ }
+
+ @Override
+ public RFC7285CostMap getCostMap(RFC7285VersionTag vtag, RFC7285CostType type) {
+ //TODO
+ return null;
+ }
+
+ @Override
+ public RFC7285CostMap getCostMap(String id, RFC7285CostMap.Filter filter) {
+ RFC7285CostMap cm = null;
+ if (filter.costType != null) {
+ cm = getCostMap(id, filter.costType);
+ } else {
+ cm = getCostMap(id);
+ }
+
+ if (cm == null)
+ return null;
+
+ if (filter.pids != null) {
+ if (filter.pids.src == null)
+ filter.pids.src = new LinkedList<String>(cm.map.keySet());
+ if (filter.pids.dst == null)
+ filter.pids.dst = new LinkedList<String>(cm.map.keySet());
+
+ Map<String, Map<String, Object>> data = new LinkedHashMap<String, Map<String, Object>>();
+ for (String src: filter.pids.src) {
+ if (!cm.map.containsKey(src))
+ continue;
+ if (data.containsKey(src))
+ continue;
+ Map<String, Object> old_data = cm.map.get(src);
+ if (old_data == null)
+ continue;
+
+ Map<String, Object> new_data = new LinkedHashMap<String, Object>();
+ for (String dst: filter.pids.dst) {
+ if (!old_data.containsKey(dst))
+ continue;
+ if (new_data.containsKey(dst))
+ continue;
+ new_data.put(dst, old_data.get(dst));
+ }
+ data.put(src, new_data);
+ }
+ cm.map = data;
+ }
+ return cm;
+ }
+
+ @Override
+ public RFC7285CostMap getCostMap(RFC7285VersionTag vtag, RFC7285CostMap.Filter filter) {
+ //TODO
+ return null;
+ }
+
+ @Override
+ public Boolean supportCostType(String id, RFC7285CostType type) {
+ //TODO
+ return true;
+ }
+
+ @Override
+ public Boolean supportCostType(RFC7285VersionTag vtag, RFC7285CostType type) {
+ //TODO
+ return true;
+ }
+
+ @Override
+ public Boolean validateCostMapFilter(String id, RFC7285CostMap.Filter filter) {
+ //TODO
+ return true;
+ }
+
+ @Override
+ public Boolean validateCostMapFilter(RFC7285VersionTag vtag, RFC7285CostMap.Filter filter) {
+ //TODO
+ return true;
+ }
+
protected InstanceIdentifier<DefaultAltoNetworkMap> getDefaultNetworkMapIID() {
InstanceIdentifier<DefaultAltoNetworkMap> iid = InstanceIdentifier.builder(Resources.class)
.child(IRD.class)
.build();
return iid;
}
+
+ protected InstanceIdentifier<CostMap> getCostMapIID(String resource_id) {
+ CostMapKey key = new CostMapKey(ResourceId.getDefaultInstance(resource_id));
+ InstanceIdentifier<CostMap> iid = InstanceIdentifier.builder(Resources.class)
+ .child(CostMaps.class)
+ .child(CostMap.class, key)
+ .build();
+ return iid;
+ }
}
Code Review / alto.git / commitdiff