tree 1489fd304bbdab37bf13e0fbcf6f177c91990a07
parent 128c23b316ba3a89a40ef87489cb8710f767609c
author Jonathan Hart <jono@onlab.us> 1397861803 -0700
committer Gerrit Code Review <gerrit2@gerrit.onos.onlab.us> 1398103766 -0700

Renamed SDN-IP packages and classes.

The code use to use the name 'BgpRoute' in a number of places, which is not
descriptive and doesn't map to how we talk about SDN-IP (we always call it
SDN-IP in all other documents/presentations).

Details of changes are as follows:

net.onrc.onos.apps.bgproute -> net.onrc.onos.apps.sdnip
    BgpRoute.java -> SdnIp.java
    IBgpRouteService.java -> ISdnIpService.java

created new package for web classes: net.onrc.onos.apps.sdnip.web
    BgpRouteResource.java -> IncomingRequestResource.java
    BgpRouteResourceSynch.java -> OutgoingRequestResource.java
    BgpRouteWebRoutable.java -> SdnIpWebRoutable.java

Change-Id: Ie6b1cbe4e95736d4cbd53b9f4def7cc3e0b46132
