/** @param network */
  private void mockDAOs(final NetworkVO network, final NetworkOfferingVO offering) {
    when(_networkDao.acquireInLockTable(
            network.getId(), NetworkOrchestrationService.NetworkLockTimeout.value()))
        .thenReturn(network);
    when(_networksDao.acquireInLockTable(
            network.getId(), NetworkOrchestrationService.NetworkLockTimeout.value()))
        .thenReturn(network);
    when(_physicalProviderDao.findByServiceProvider(0L, "VirtualRouter"))
        .thenReturn(new PhysicalNetworkServiceProviderVO());
    when(_vrProviderDao.findByNspIdAndType(0L, Type.VirtualRouter))
        .thenReturn(new VirtualRouterProviderVO());
    when(_networkOfferingDao.findById(0L)).thenReturn(offering);
    // watchit: (in this test) there can be only one
    when(_routerDao.getNextInSequence(Long.class, "id")).thenReturn(0L);
    final ServiceOfferingVO svcoff =
        new ServiceOfferingVO(
            "name",
            /* cpu */ 1,
            /* ramsize */ 1024 * 1024,
            /* (clock?)speed */ 1024 * 1024 * 1024,
            /* rateMbps */ 1,
            /* multicastRateMbps */ 0,
            /* offerHA */ false,
            "displayText",
            ProvisioningType.THIN,
            /* useLocalStorage */ false,
            /* recreatable */ false,
            "tags",
            /* systemUse */ false,
            VirtualMachine.Type.DomainRouter,
            /* defaultUse */ false);
    when(_serviceOfferingDao.findById(0L)).thenReturn(svcoff);
    final DomainRouterVO router =
        new DomainRouterVO(
            /* id */ 1L,
            /* serviceOfferingId */ 1L,
            /* elementId */ 0L,
            "name",
            /* templateId */ 0L,
            HypervisorType.XenServer,
            /* guestOSId */ 0L,
            /* domainId */ 0L,
            /* accountId */ 1L,
            /* userId */ 1L,
            /* isRedundantRouter */ false,
            RedundantState.UNKNOWN,
            /* haEnabled */ false,
            /* stopPending */ false,
            /* vpcId */ null);

    when(_routerDao.getNextInSequence(Long.class, "id")).thenReturn(1L);
    when(_templateDao.findRoutingTemplate(
            HypervisorType.XenServer, "SystemVM Template (XenServer)"))
        .thenReturn(new VMTemplateVO());
    when(_routerDao.persist(any(DomainRouterVO.class))).thenReturn(router);
    when(_routerDao.findById(router.getId())).thenReturn(router);
  }
Ejemplo n.º 2
0
 @Override
 public NetworkVO getPrivateNetwork(
     String broadcastUri, String cidr, long accountId, long zoneId, Long networkOfferingId) {
   if (networkOfferingId == null) {
     networkOfferingId =
         _ntwkOffDao.findByUniqueName(NetworkOffering.SystemPrivateGatewayNetworkOffering).getId();
   }
   SearchCriteria<NetworkVO> sc = AllFieldsSearch.create();
   sc.setParameters("datacenter", zoneId);
   sc.setParameters("broadcastUri", broadcastUri);
   sc.setParameters("cidr", cidr);
   sc.setParameters("account", accountId);
   sc.setParameters("offering", networkOfferingId);
   return findOneBy(sc);
 }
Ejemplo n.º 3
0
 @Override
 @DB
 public void addRouterToGuestNetwork(VirtualRouter router, Network guestNetwork) {
   if (_routerNetworkDao.findByRouterAndNetwork(router.getId(), guestNetwork.getId()) == null) {
     NetworkOffering off = _offDao.findById(guestNetwork.getNetworkOfferingId());
     if (!(off.getName().equalsIgnoreCase(NetworkOffering.SystemPrivateGatewayNetworkOffering))) {
       TransactionLegacy txn = TransactionLegacy.currentTxn();
       txn.start();
       // 1) add router to network
       RouterNetworkVO routerNtwkMap =
           new RouterNetworkVO(router.getId(), guestNetwork.getId(), guestNetwork.getGuestType());
       _routerNetworkDao.persist(routerNtwkMap);
       // 2) create user stats entry for the network
       UserStatisticsVO stats =
           _userStatsDao.findBy(
               router.getAccountId(),
               router.getDataCenterId(),
               guestNetwork.getId(),
               null,
               router.getId(),
               router.getType().toString());
       if (stats == null) {
         stats =
             new UserStatisticsVO(
                 router.getAccountId(),
                 router.getDataCenterId(),
                 null,
                 router.getId(),
                 router.getType().toString(),
                 guestNetwork.getId());
         _userStatsDao.persist(stats);
       }
       txn.commit();
     }
   }
 }
Ejemplo n.º 4
0
  @PostConstruct
  protected void init() {
    AllFieldsSearch = createSearchBuilder();
    AllFieldsSearch.and("trafficType", AllFieldsSearch.entity().getTrafficType(), Op.EQ);
    AllFieldsSearch.and("cidr", AllFieldsSearch.entity().getCidr(), Op.EQ);
    AllFieldsSearch.and("broadcastType", AllFieldsSearch.entity().getBroadcastDomainType(), Op.EQ);
    AllFieldsSearch.and("offering", AllFieldsSearch.entity().getNetworkOfferingId(), Op.EQ);
    AllFieldsSearch.and("datacenter", AllFieldsSearch.entity().getDataCenterId(), Op.EQ);
    AllFieldsSearch.and("account", AllFieldsSearch.entity().getAccountId(), Op.EQ);
    AllFieldsSearch.and("related", AllFieldsSearch.entity().getRelated(), Op.EQ);
    AllFieldsSearch.and("guestType", AllFieldsSearch.entity().getGuestType(), Op.EQ);
    AllFieldsSearch.and("physicalNetwork", AllFieldsSearch.entity().getPhysicalNetworkId(), Op.EQ);
    AllFieldsSearch.and("broadcastUri", AllFieldsSearch.entity().getBroadcastUri(), Op.EQ);
    AllFieldsSearch.and("vpcId", AllFieldsSearch.entity().getVpcId(), Op.EQ);
    AllFieldsSearch.and("aclId", AllFieldsSearch.entity().getNetworkACLId(), Op.EQ);
    SearchBuilder<NetworkOfferingVO> join1 = _ntwkOffDao.createSearchBuilder();
    join1.and("isSystem", join1.entity().isSystemOnly(), Op.EQ);
    join1.and("isRedundant", join1.entity().getRedundantRouter(), Op.EQ);
    AllFieldsSearch.join(
        "offerings",
        join1,
        AllFieldsSearch.entity().getNetworkOfferingId(),
        join1.entity().getId(),
        JoinBuilder.JoinType.INNER);
    AllFieldsSearch.done();

    AccountSearch = createSearchBuilder();
    AccountSearch.and("offering", AccountSearch.entity().getNetworkOfferingId(), Op.EQ);
    SearchBuilder<NetworkAccountVO> join = _accountsDao.createSearchBuilder();
    join.and("account", join.entity().getAccountId(), Op.EQ);
    AccountSearch.join(
        "accounts",
        join,
        AccountSearch.entity().getId(),
        join.entity().getNetworkId(),
        JoinBuilder.JoinType.INNER);
    AccountSearch.and("datacenter", AccountSearch.entity().getDataCenterId(), Op.EQ);
    AccountSearch.and("cidr", AccountSearch.entity().getCidr(), Op.EQ);
    AccountSearch.and("vpcId", AccountSearch.entity().getVpcId(), Op.EQ);
    AccountSearch.done();

    RelatedConfigSearch = createSearchBuilder();
    RelatedConfigSearch.and("offering", RelatedConfigSearch.entity().getNetworkOfferingId(), Op.EQ);
    RelatedConfigSearch.and("datacenter", RelatedConfigSearch.entity().getDataCenterId(), Op.EQ);
    SearchBuilder<NetworkAccountVO> join2 = _accountsDao.createSearchBuilder();
    join2.and("account", join2.entity().getAccountId(), Op.EQ);
    RelatedConfigSearch.join(
        "account",
        join2,
        join2.entity().getNetworkId(),
        RelatedConfigSearch.entity().getId(),
        JoinType.INNER);
    RelatedConfigSearch.done();

    AccountNetworkSearch = createSearchBuilder();
    AccountNetworkSearch.and("networkId", AccountNetworkSearch.entity().getId(), Op.EQ);
    SearchBuilder<NetworkAccountVO> mapJoin = _accountsDao.createSearchBuilder();
    mapJoin.and("accountId", mapJoin.entity().getAccountId(), Op.EQ);
    AccountNetworkSearch.join(
        "networkSearch",
        mapJoin,
        AccountNetworkSearch.entity().getId(),
        mapJoin.entity().getNetworkId(),
        JoinBuilder.JoinType.INNER);
    AccountNetworkSearch.done();

    ZoneBroadcastUriSearch = createSearchBuilder();
    ZoneBroadcastUriSearch.and(
        "dataCenterId", ZoneBroadcastUriSearch.entity().getDataCenterId(), Op.EQ);
    ZoneBroadcastUriSearch.and(
        "broadcastUri", ZoneBroadcastUriSearch.entity().getBroadcastUri(), Op.EQ);
    ZoneBroadcastUriSearch.and("guestType", ZoneBroadcastUriSearch.entity().getGuestType(), Op.EQ);
    ZoneBroadcastUriSearch.done();

    CountByZoneAndURI = createSearchBuilder(Long.class);
    CountByZoneAndURI.select(null, Func.COUNT, null);
    CountByZoneAndURI.and("dataCenterId", CountByZoneAndURI.entity().getDataCenterId(), Op.EQ);
    CountByZoneAndURI.and("broadcastUri", CountByZoneAndURI.entity().getBroadcastUri(), Op.EQ);
    CountByZoneAndURI.and("guestType", CountByZoneAndURI.entity().getGuestType(), Op.EQ);

    CountByZoneAndURI.done();

    ZoneSecurityGroupSearch = createSearchBuilder();
    ZoneSecurityGroupSearch.and(
        "dataCenterId", ZoneSecurityGroupSearch.entity().getDataCenterId(), Op.EQ);
    SearchBuilder<NetworkServiceMapVO> offJoin = _ntwkSvcMap.createSearchBuilder();
    offJoin.and("service", offJoin.entity().getService(), Op.EQ);
    ZoneSecurityGroupSearch.join(
        "services",
        offJoin,
        ZoneSecurityGroupSearch.entity().getId(),
        offJoin.entity().getNetworkId(),
        JoinBuilder.JoinType.INNER);
    ZoneSecurityGroupSearch.done();

    CountBy = createSearchBuilder(Integer.class);
    CountBy.select(null, Func.COUNT, CountBy.entity().getId());
    CountBy.and("offeringId", CountBy.entity().getNetworkOfferingId(), Op.EQ);
    CountBy.and("vpcId", CountBy.entity().getVpcId(), Op.EQ);
    CountBy.and("removed", CountBy.entity().getRemoved(), Op.NULL);
    SearchBuilder<NetworkOfferingVO> ntwkOffJoin = _ntwkOffDao.createSearchBuilder();
    ntwkOffJoin.and("isSystem", ntwkOffJoin.entity().isSystemOnly(), Op.EQ);
    CountBy.join(
        "offerings",
        ntwkOffJoin,
        CountBy.entity().getNetworkOfferingId(),
        ntwkOffJoin.entity().getId(),
        JoinBuilder.JoinType.INNER);
    CountBy.done();

    PhysicalNetworkSearch = createSearchBuilder();
    PhysicalNetworkSearch.and(
        "physicalNetworkId", PhysicalNetworkSearch.entity().getPhysicalNetworkId(), Op.EQ);
    PhysicalNetworkSearch.done();

    SecurityGroupSearch = createSearchBuilder();
    SearchBuilder<NetworkServiceMapVO> join3 = _ntwkSvcMap.createSearchBuilder();
    join3.and("service", join3.entity().getService(), Op.EQ);
    SecurityGroupSearch.join(
        "services",
        join3,
        SecurityGroupSearch.entity().getId(),
        join3.entity().getNetworkId(),
        JoinBuilder.JoinType.INNER);
    SecurityGroupSearch.done();

    NetworksCount = createSearchBuilder(Integer.class);
    NetworksCount.select(null, Func.COUNT, NetworksCount.entity().getId());
    NetworksCount.and(
        "networkOfferingId", NetworksCount.entity().getNetworkOfferingId(), SearchCriteria.Op.EQ);
    NetworksCount.done();

    NetworksRegularUserCanCreateSearch = createSearchBuilder(Long.class);
    NetworksRegularUserCanCreateSearch.and(
        "aclType", NetworksRegularUserCanCreateSearch.entity().getAclType(), Op.EQ);
    NetworksRegularUserCanCreateSearch.select(
        null, Func.COUNT, NetworksRegularUserCanCreateSearch.entity().getId());
    SearchBuilder<NetworkAccountVO> join4 = _accountsDao.createSearchBuilder();
    join4.and("account", join4.entity().getAccountId(), Op.EQ);
    join4.and("isOwner", join4.entity().isOwner(), Op.EQ);
    NetworksRegularUserCanCreateSearch.join(
        "accounts",
        join4,
        NetworksRegularUserCanCreateSearch.entity().getId(),
        join4.entity().getNetworkId(),
        JoinBuilder.JoinType.INNER);
    SearchBuilder<NetworkOfferingVO> join5 = _ntwkOffDao.createSearchBuilder();
    join5.and("specifyVlan", join5.entity().getSpecifyVlan(), Op.EQ);
    NetworksRegularUserCanCreateSearch.join(
        "ntwkOff",
        join5,
        NetworksRegularUserCanCreateSearch.entity().getNetworkOfferingId(),
        join5.entity().getId(),
        JoinBuilder.JoinType.INNER);
    NetworksRegularUserCanCreateSearch.done();

    _tgMacAddress = _tgs.get("macAddress");

    SourceNATSearch = createSearchBuilder();
    SourceNATSearch.and("account", SourceNATSearch.entity().getAccountId(), Op.EQ);
    SourceNATSearch.and("datacenter", SourceNATSearch.entity().getDataCenterId(), Op.EQ);
    SourceNATSearch.and("guestType", SourceNATSearch.entity().getGuestType(), Op.EQ);
    SearchBuilder<NetworkServiceMapVO> join6 = _ntwkSvcMap.createSearchBuilder();
    join6.and("service", join6.entity().getService(), Op.EQ);
    SourceNATSearch.join(
        "services",
        join6,
        SourceNATSearch.entity().getId(),
        join6.entity().getNetworkId(),
        JoinBuilder.JoinType.INNER);
    SourceNATSearch.done();

    VpcNetworksCount = createSearchBuilder(Long.class);
    VpcNetworksCount.and("vpcId", VpcNetworksCount.entity().getVpcId(), Op.EQ);
    VpcNetworksCount.select(null, Func.COUNT, VpcNetworksCount.entity().getId());
    SearchBuilder<NetworkOfferingVO> join9 = _ntwkOffDao.createSearchBuilder();
    join9.and("isSystem", join9.entity().isSystemOnly(), Op.EQ);
    VpcNetworksCount.join(
        "offerings",
        join9,
        VpcNetworksCount.entity().getNetworkOfferingId(),
        join9.entity().getId(),
        JoinBuilder.JoinType.INNER);
    VpcNetworksCount.done();

    OfferingAccountNetworkSearch = createSearchBuilder();
    OfferingAccountNetworkSearch.select(
        null, Func.DISTINCT, OfferingAccountNetworkSearch.entity().getId());
    SearchBuilder<NetworkOfferingVO> ntwkOfferingJoin = _ntwkOffDao.createSearchBuilder();
    ntwkOfferingJoin.and("isSystem", ntwkOfferingJoin.entity().isSystemOnly(), Op.EQ);
    OfferingAccountNetworkSearch.join(
        "ntwkOfferingSearch",
        ntwkOfferingJoin,
        OfferingAccountNetworkSearch.entity().getNetworkOfferingId(),
        ntwkOfferingJoin.entity().getId(),
        JoinBuilder.JoinType.LEFT);
    SearchBuilder<NetworkAccountVO> ntwkAccountJoin = _accountsDao.createSearchBuilder();
    ntwkAccountJoin.and("accountId", ntwkAccountJoin.entity().getAccountId(), Op.EQ);
    OfferingAccountNetworkSearch.join(
        "ntwkAccountSearch",
        ntwkAccountJoin,
        OfferingAccountNetworkSearch.entity().getId(),
        ntwkAccountJoin.entity().getNetworkId(),
        JoinBuilder.JoinType.INNER);
    OfferingAccountNetworkSearch.and(
        "zoneId", OfferingAccountNetworkSearch.entity().getDataCenterId(), Op.EQ);
    OfferingAccountNetworkSearch.and(
        "type", OfferingAccountNetworkSearch.entity().getGuestType(), Op.EQ);
    OfferingAccountNetworkSearch.done();

    GarbageCollectedSearch = createSearchBuilder(Long.class);
    GarbageCollectedSearch.selectFields(GarbageCollectedSearch.entity().getId());
    SearchBuilder<NetworkOpVO> join7 = _ntwkOpDao.createSearchBuilder();
    join7.and("activenics", join7.entity().getActiveNicsCount(), Op.EQ);
    join7.and("gc", join7.entity().isGarbageCollected(), Op.EQ);
    join7.and("check", join7.entity().isCheckForGc(), Op.EQ);
    GarbageCollectedSearch.join(
        "ntwkOpGC",
        join7,
        GarbageCollectedSearch.entity().getId(),
        join7.entity().getId(),
        JoinBuilder.JoinType.INNER);
    SearchBuilder<NetworkOfferingVO> join8 = _ntwkOffDao.createSearchBuilder();
    join8.and("isPersistent", join8.entity().getIsPersistent(), Op.EQ);
    GarbageCollectedSearch.join(
        "ntwkOffGC",
        join8,
        GarbageCollectedSearch.entity().getNetworkOfferingId(),
        join8.entity().getId(),
        JoinBuilder.JoinType.INNER);
    GarbageCollectedSearch.done();
  }