예제 #1
0
def _create_ipv4_intr_from_range(label, domain_name, system, mac, range_start,
                                 range_end):
    if range_start >= range_end - 1:
        errors['ip'] = ErrorList(["The start ip must be less than end ip."])
        return None, errors

    ip = find_free_ip(range_start, range_end, ip_type='4')
    errors = ErrorDict()
    if not ip:
        errors['ip'] = ErrorList([
            "Could not find free ip in range {0} - "
            "{1}".format(range_start, range_end)
        ])
        return None, errors

    domain = ensure_domain(domain_name, inherit_soa=True)
    try:
        intr = StaticInterface(label=label,
                               domain=domain,
                               ip_str=str(ip),
                               ip_type='4',
                               system=system,
                               mac=mac)
        intr.clean()
    except ValidationError, e:
        errors['interface'] = ErrorList(e.messages)
예제 #2
0
 def do_add_intr(self, mac, label, domain, ip_str, ip_type='4'):
     r = StaticInterface(mac=mac, label=label, domain=domain, ip_str=ip_str,
                         ip_type=ip_type, system=self.n)
     r.clean()
     r.save()
     repr(r)
     return r
예제 #3
0
    def test_cleanup_intr(self):
        self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
        self.assertTrue(Domain.objects.filter(name="foo.poo"))

        Domain.objects.get_or_create(name="arpa")
        Domain.objects.get_or_create(name="in-addr.arpa")
        Domain.objects.get_or_create(name="10.in-addr.arpa")

        fqdn = "bar.x.y.z.foo.poo"
        label, the_domain = ensure_label_domain(fqdn)
        system = System()
        addr = StaticInterface(
            label=label, domain=the_domain, ip_type='4', ip_str="10.2.3.4",
            mac="00:11:22:33:44:55", system=system
        )
        addr.save()
        self.assertFalse(prune_tree(the_domain))
        addr.delete()

        self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
        self.assertTrue(Domain.objects.filter(name="foo.poo"))
예제 #4
0
 def test_update_glue_record_intr(self):
     # Glue records can't change their name.
     glue = StaticInterface(
         label="ns788", domain=self.r, ip_str="128.193.1.10", ip_type="4", system=self.s, mac="11:22:33:44:55:66"
     )
     glue.save()
     data = {"domain": self.r, "server": "ns788.ru"}
     ns = self.do_add(**data)
     self.assertTrue(ns.glue)
     glue.label = "asdfasdf"
     self.assertRaises(ValidationError, glue.clean)
예제 #5
0
    def test_update_glue_to_no_intr(self):
        glue = StaticInterface(
            label="ns34", domain=self.r, ip_str="128.193.1.10", ip_type="4", system=self.s, mac="11:22:33:44:55:66"
        )
        glue.save()
        data = {"domain": self.r, "server": "ns34.ru"}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)

        ns.server = "ns4.wee"
        ns.save()
        self.assertTrue(ns.glue is None)
예제 #6
0
    def test_update_glue_to_no_intr(self):
        glue = StaticInterface(label='ns34', domain=self.r,
                               ip_str='128.193.1.10', ip_type='4',
                               system=self.s, mac="11:22:33:44:55:66")
        glue.save()
        data = {'domain': self.r, 'server': 'ns34.ru'}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)

        ns.server = "ns4.wee"
        ns.save()
        self.assertTrue(ns.glue is None)
예제 #7
0
    def test_disallow_delete_of_glue_intr(self):
        # Interface glue records should not be allowed to be deleted.
        glue = StaticInterface(
            label="ns24", domain=self.f_r, ip_str="128.193.99.10", ip_type="4", system=self.s, mac="11:22:33:44:55:66"
        )
        glue.clean()
        glue.save()
        data = {"domain": self.f_r, "server": "ns24.foo.ru"}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.glue, glue)

        self.assertRaises(ValidationError, glue.delete)
예제 #8
0
    def test_intr_exists(self):
        label = "tdfestyfoo"
        data = "waasdft"
        dom, _ = Domain.objects.get_or_create(name="cd")
        dom, _ = Domain.objects.get_or_create(name="what.cd")

        intr = StaticInterface(label=label, domain=dom, ip_str="10.0.0.1",
                               ip_type='4', system=self.s, mac="11:22:33:44:55:66")
        intr.clean()
        intr.save()

        cn = CNAME(label=label, domain=dom, target=data)
        self.assertRaises(ValidationError, cn.full_clean)
예제 #9
0
 def test_update_glue_record_intr(self):
     # Glue records can't change their name.
     glue = StaticInterface(label='ns788',
                            domain=self.r,
                            ip_str='128.193.1.10',
                            ip_type='4',
                            system=self.s,
                            mac="11:22:33:44:55:66")
     glue.save()
     data = {'domain': self.r, 'server': 'ns788.ru'}
     ns = self.do_add(**data)
     self.assertTrue(ns.glue)
     glue.label = "asdfasdf"
     self.assertRaises(ValidationError, glue.clean)
예제 #10
0
    def test_update_glue_to_no_intr(self):
        glue = StaticInterface(label='ns34',
                               domain=self.r,
                               ip_str='128.193.1.10',
                               ip_type='4',
                               system=self.s,
                               mac="11:22:33:44:55:66")
        glue.save()
        data = {'domain': self.r, 'server': 'ns34.ru'}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)

        ns.server = "ns4.wee"
        ns.save()
        self.assertTrue(ns.glue is None)
예제 #11
0
 def test_private_view_case_1_intr(self):
     intr = StaticInterface(label="asf", domain=self.f_o, ip_str="10.0.0.1",
                            ip_type="4", mac="00:11:22:33:44:55", system=self.s)
     intr.clean()
     intr.save()
     # Object has to exist before views can be assigned.
     intr.views.add(self.private)
     intr.save()
예제 #12
0
    def test_manual_assign_of_glue(self):
        # Test that assigning a different glue record doesn't get overriden by
        # the auto assinging during the Nameserver's clean function.
        glue = StaticInterface(
            label="ns25", domain=self.f_r, ip_str="128.193.99.10", ip_type="4", system=self.s, mac="11:22:33:44:55:66"
        )
        glue.clean()
        glue.save()
        data = {"domain": self.f_r, "server": "ns25.foo.ru"}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.glue, glue)

        glue2 = AddressRecord(label="ns25", domain=self.f_r, ip_str="128.193.1.78", ip_type="4")
        glue2.clean()
        glue2.save()

        ns.clean()

        # Make sure things didn't get overriden.
        self.assertEqual(ns.glue, glue)

        ns.glue = glue2
        ns.save()
        # Refresh the object
        ns = Nameserver.objects.get(pk=ns.pk)
        # Again, Make sure things didn't get overriden.
        self.assertEqual(ns.glue, glue2)
        # Make sure we still can't delete.
        self.assertRaises(ValidationError, glue2.delete)
        self.assertRaises(ValidationError, ns.glue.delete)

        # We shuold be able to delelte the other one.
        glue.delete()
예제 #13
0
파일: api.py 프로젝트: Ziaunys/chili
 class Meta:
     always_return_data = True
     queryset = StaticInterface.objects.all()
     fields = StaticInterface.get_api_fields() + [
         'domain', 'views', 'system'
     ]
     authorization = Authorization()
     allowed_methods = allowed_methods
     resource_name = 'staticinterface'
예제 #14
0
파일: ipv6_basic.py 프로젝트: Ziaunys/chili
 def test1_no_system(self):
     mac = "15:22:33:44:55:66"
     label = "8888foo"
     domain = self.f_c
     ip_str = "188::" + mac
     ip_type = '6'
     r = StaticInterface(label=label, domain=domain, ip_str=ip_str,
                         ip_type=ip_type, system=None)
     self.assertRaises(ValidationError, r.clean)
예제 #15
0
파일: utils.py 프로젝트: Ziaunys/chili
def _create_ipv4_intr_from_range(label, domain_name, system, mac, range_start,
                                 range_end):
    if range_start >= range_end - 1:
        errors['ip'] = ErrorList(["The start ip must be less than end ip."])
        return None, errors

    ip = find_free_ip(range_start, range_end, ip_type='4')
    errors = ErrorDict()
    if not ip:
        errors['ip'] = ErrorList(["Could not find free ip in range {0} - "
                                  "{1}".format(range_start, range_end)])
        return None, errors

    domain = ensure_domain(domain_name, inherit_soa=True)
    try:
        intr = StaticInterface(label=label, domain=domain, ip_str=str(ip),
                               ip_type='4', system=system, mac=mac)
        intr.clean()
    except ValidationError, e:
        errors['interface'] = ErrorList(e.messages)
예제 #16
0
    def test_intr_cname_exists(self):
        # Duplicate test?
        label = "tesafstyfoo"
        data = "wadfakt"
        dom, _ = Domain.objects.get_or_create(name="cd")
        dom, _ = Domain.objects.get_or_create(name="what.cd")

        cn, _ = CNAME.objects.get_or_create(
            label=label, domain=dom, target=data)
        cn.full_clean()
        cn.save()

        intr = StaticInterface(label=label, domain=dom, ip_str="10.0.0.2",
                               ip_type='4', system=self.s, mac="00:11:22:33:44:55")

        self.assertRaises(ValidationError, intr.clean)
        cn.label = "differentlabel"
        cn.save()
        intr.clean()
        intr.save()
예제 #17
0
파일: auto_delete.py 프로젝트: jirwin/cyder
    def test_cleanup_intr(self):
        self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
        self.assertTrue(Domain.objects.filter(name="foo.poo"))

        Domain.objects.get_or_create(name="arpa")
        Domain.objects.get_or_create(name="in-addr.arpa")
        Domain.objects.get_or_create(name="10.in-addr.arpa")

        fqdn = "bar.x.y.z.foo.poo"
        label, the_domain = ensure_label_domain(fqdn)
        system = System()
        addr = StaticInterface(label=label,
                               domain=the_domain,
                               ip_type='4',
                               ip_str="10.2.3.4",
                               mac="00:11:22:33:44:55",
                               system=system)
        addr.save()
        self.assertFalse(prune_tree(the_domain))
        addr.delete()

        self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
        self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
        self.assertTrue(Domain.objects.filter(name="foo.poo"))
예제 #18
0
파일: A_tests.py 프로젝트: jirwin/cyder
 def do_add_intr(self, mac, label, domain, ip_str, ip_type='4'):
     r = StaticInterface(mac=mac, label=label, domain=domain, ip_str=ip_str,
                         ip_type=ip_type, system=self.n)
     r.clean()
     r.save()
     repr(r)
     return r
예제 #19
0
파일: test_models.py 프로젝트: jirwin/cyder
    def test_intr_cname_exists(self):
        # Duplicate test?
        label = "tesafstyfoo"
        data = "wadfakt"
        dom, _ = Domain.objects.get_or_create(name="cd")
        dom, _ = Domain.objects.get_or_create(name="what.cd")

        cn, _ = CNAME.objects.get_or_create(label=label,
                                            domain=dom,
                                            target=data)
        cn.full_clean()
        cn.save()

        intr = StaticInterface(label=label,
                               domain=dom,
                               ip_str="10.0.0.2",
                               ip_type='4',
                               system=self.s,
                               mac="00:11:22:33:44:55")

        self.assertRaises(ValidationError, intr.clean)
        cn.label = "differentlabel"
        cn.save()
        intr.clean()
        intr.save()
예제 #20
0
    def testtest_add_ns_in_domain_intr(self):
        # Use an Interface as a glue record.
        glue = StaticInterface(
            label="ns232", domain=self.r, ip_str="128.193.99.10", ip_type="4", system=self.s, mac="12:23:45:45:45:45"
        )
        glue.clean()
        glue.save()
        data = {"domain": self.r, "server": "ns232.ru"}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.server, ns.glue.fqdn)
        self.assertRaises(ValidationError, glue.delete)

        glue = StaticInterface(
            label="ns332", domain=self.f_r, ip_str="128.193.1.10", ip_type="4", system=self.s, mac="11:22:33:44:55:66"
        )
        glue.clean()
        glue.save()
        data = {"domain": self.f_r, "server": "ns332.foo.ru"}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.server, ns.glue.fqdn)
예제 #21
0
 def add_intr_ipv4(self, ip):
     intr = StaticInterface(
         label=random_label(), domain=self.domain, ip_str=ip, ip_type='4',
         system=self.s, mac='11:22:33:44:55:66'
     )
     intr.clean()
     intr.save()
     return intr
예제 #22
0
    def test_disallow_name_update_of_glue_Intr(self):
        # Glue records should not be allowed to change their name.
        glue = StaticInterface(label='ns24',
                               domain=self.f_r,
                               ip_str='128.193.99.10',
                               ip_type='4',
                               system=self.s,
                               mac="11:22:33:44:55:66")
        glue.clean()
        glue.save()
        data = {'domain': self.f_r, 'server': 'ns24.foo.ru'}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.glue, glue)

        glue.label = "ns22"
        self.assertRaises(ValidationError, glue.clean)
예제 #23
0
    def test_manual_assign_of_glue(self):
        # Test that assigning a different glue record doesn't get overriden by
        # the auto assinging during the Nameserver's clean function.
        glue = StaticInterface(label='ns25',
                               domain=self.f_r,
                               ip_str='128.193.99.10',
                               ip_type='4',
                               system=self.s,
                               mac="11:22:33:44:55:66")
        glue.clean()
        glue.save()
        data = {'domain': self.f_r, 'server': 'ns25.foo.ru'}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.glue, glue)

        glue2 = AddressRecord(label='ns25',
                              domain=self.f_r,
                              ip_str='128.193.1.78',
                              ip_type='4')
        glue2.clean()
        glue2.save()

        ns.clean()

        # Make sure things didn't get overriden.
        self.assertEqual(ns.glue, glue)

        ns.glue = glue2
        ns.save()
        # Refresh the object
        ns = Nameserver.objects.get(pk=ns.pk)
        # Again, Make sure things didn't get overriden.
        self.assertEqual(ns.glue, glue2)
        # Make sure we still can't delete.
        self.assertRaises(ValidationError, glue2.delete)
        self.assertRaises(ValidationError, ns.glue.delete)

        # We shuold be able to delelte the other one.
        glue.delete()
예제 #24
0
    def test_disallow_name_update_of_glue_Intr(self):
        # Glue records should not be allowed to change their name.
        glue = StaticInterface(label='ns24', domain=self.f_r,
                               ip_str='128.193.99.10', ip_type='4',
                               system=self.s, mac="11:22:33:44:55:66")
        glue.clean()
        glue.save()
        data = {'domain': self.f_r, 'server': 'ns24.foo.ru'}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.glue, glue)

        glue.label = "ns22"
        self.assertRaises(ValidationError, glue.clean)
예제 #25
0
파일: views.py 프로젝트: Ziaunys/chili
def do_combine_a_ptr_to_interface(
        addr, ptr, system, mac_address=None,
        interface=None, dhcp_hostname=None,
        dhcp_domain_name=None, dhcp_domain_name_servers=None,
        dhcp_filename=None):

    if mac_address == '00:00:00:00:00:00' or mac_address is None:
        next_adapter = system.get_next_key_value_adapter()
    if (addr.ip_str != ptr.ip_str or addr.fqdn != ptr.name or
            addr.ip_type != ptr.ip_type):
        raise ValidationError("This A and PTR have different data.")

    intr = StaticInterface(
        label=addr.label, mac=mac_address, domain=addr.domain,
        ip_str=addr.ip_str, ip_type=addr.ip_type, system=system)
    addr_deleted = False
    ptr_deleted = False

    addr.delete(check_cname=False)
    addr_deleted = True
    ptr.delete()
    ptr_deleted = True
    intr.full_clean()
    intr.save()
    if interface:
        from cyder.core.systems.system_api import SystemResource
        intr.update_attrs()
        adapter_type, primary, alias = SystemResource.extract_nic_attrs(
            interface)
        intr.attrs.primary = primary
        intr.attrs.alias = alias
        intr.attrs.interface_type = adapter_type
        if dhcp_hostname:
            intr.attrs.hostname = dhcp_hostname

        if dhcp_filename:
            intr.attrs.filename = dhcp_filename

        if dhcp_domain_name:
            intr.attrs.domain_name = dhcp_domain_name

        if dhcp_domain_name_servers:
            intr.attrs.domain_name_servers = dhcp_domain_name_servers

    return intr, addr_deleted, ptr_deleted
예제 #26
0
파일: test_models.py 프로젝트: jirwin/cyder
    def test_intr_exists(self):
        label = "tdfestyfoo"
        data = "waasdft"
        dom, _ = Domain.objects.get_or_create(name="cd")
        dom, _ = Domain.objects.get_or_create(name="what.cd")

        intr = StaticInterface(label=label,
                               domain=dom,
                               ip_str="10.0.0.1",
                               ip_type='4',
                               system=self.s,
                               mac="11:22:33:44:55:66")
        intr.clean()
        intr.save()

        cn = CNAME(label=label, domain=dom, target=data)
        self.assertRaises(ValidationError, cn.full_clean)
예제 #27
0
    def test_bad_nameserver_soa_state_case_1_4(self):
        # This is Case 1 ... with StaticInterfaces's
        reverse_root_domain = create_fake_zone("14.in-addr.arpa", suffix="")
        root_domain = create_fake_zone("asdf14")
        for ns in root_domain.nameserver_set.all():
            ns.delete()

        # At his point we should have a domain at the root of a zone with no
        # other records in it.

        # Let's create a child domain and try to add a record there.
        cdomain = Domain(name="10.14.in-addr.arpa")
        cdomain.soa = reverse_root_domain.soa
        cdomain.save()

        # Adding a record shouldn't be allowed because there is no NS record on
        # the zone's root domain.
        intr = StaticInterface(label="asdf",
                               domain=root_domain,
                               ip_str="14.10.1.1",
                               ip_type="4",
                               mac="11:22:33:44:55:66",
                               system=self.s)
        self.assertRaises(ValidationError, intr.save)
예제 #28
0
    def gen_static(self):
        """
        Generates the Static Interface objects related to this zone's domain.

        .. note::
            Every static interface needs a system.

        :System uniqueness: hostname, mac, ip_str

        :StaticInterface uniqueness: hostname, mac, ip_str
        """
        from dhcp_migrate import migrate_zones

        if Ctnr.objects.count() <= 2:
            print "WARNING: Zones not migrated. Attempting to migrate now."
            migrate_zones()

        sys_value_keys = {"type": "Hardware Type",
                          "os": "Operating System",
                          "location": "Location",
                          "department": "Department",
                          "serial": "Serial Number",
                          "other_id": "Other ID",
                          "purchase_date": "Purchase Date",
                          "po_number": "PO Number",
                          "warranty_date": "Warranty Date",
                          "owning_unit": "Owning Unit",
                          "user_id": "User ID"}

        keys = ("host.id", "ip", "host.name", "zone.name", "workgroup",
                "enabled", "ha", "zone", "type", "os", "location",
                "department", "serial", "other_id", "purchase_date",
                "po_number", "warranty_date", "owning_unit", "user_id",
                "last_seen", "expire", "ttl", "last_update")

        sql = ("SELECT %s FROM host JOIN zone ON host.zone = zone.id "
               "WHERE ip != 0 AND domain = '%s';" %
               (", ".join(keys), self.domain_id))

        cursor.execute(sql)
        for values in cursor.fetchall():
            items = dict(zip(keys, values))
            ctnr = self.ctnr_from_zone_name(items['zone.name'])
            if ctnr is None:
                continue

            name = items['host.name']
            enabled = bool(items['enabled'])
            dns_enabled, dhcp_enabled = enabled, enabled
            ip = items['ip']
            ha = items['ha']
            if ip == 0:
                continue

            if len(ha) != 12 or ha == '0' * 12:
                ha = ""

            if ha == "":
                dhcp_enabled = False

            # check for duplicate
            static = StaticInterface.objects.filter(
                label=name, mac=(clean_mac(ha) or None), ip_str=long2ip(ip))
            if static:
                stderr.write("Ignoring host %s: already exists.\n"
                             % items['host.id'])
                continue

            # create system
            system = System(name=name)
            system.save()
            for key in sys_value_keys.keys():
                value = items[key].strip()
                if not value or value == '0':
                    continue
                attr = Attribute.objects.get(
                    name=fix_attr_name(sys_value_keys[key]))
                eav = SystemAV(entity=system, attribute=attr, value=value)
                eav.full_clean()
                eav.save()

            # check for workgroup
            if items['workgroup'] is not None:
                cursor.execute("SELECT name "
                               "FROM workgroup "
                               "WHERE id = {0}".format(items['workgroup']))
                wname = cursor.fetchone()[0]
                w, _ = Workgroup.objects.get_or_create(name=wname)
            else:
                w = None

            last_seen = items['last_seen'] or None
            if last_seen:
                last_seen = datetime.fromtimestamp(last_seen)

            static = StaticInterface(
                label=name, domain=self.domain, mac=(clean_mac(ha) or None),
                system=system, ip_str=long2ip(ip), ip_type='4',
                workgroup=w, ctnr=ctnr, ttl=items['ttl'],
                dns_enabled=dns_enabled, dhcp_enabled=dhcp_enabled,
                last_seen=last_seen)

            # create static interface
            try:
                static.save(update_range_usage=False)
            except ValidationError as e:
                try:
                    static.dhcp_enabled = False
                    static.dns_enabled = dns_enabled
                    static.save(update_range_usage=False)
                    stderr.write('WARNING: Static interface with IP {} has '
                                 'been disabled\n'.format(static.ip_str))
                    stderr.write('    {}\n'.format(e))
                except ValidationError as e:
                    stderr.write('WARNING: Could not create static interface '
                                 'with IP {}\n'.format(static.ip_str))
                    stderr.write('    {}\n'.format(e))
                    static = None
                    system.delete()

            if static:
                static.views.add(public)
                static.views.add(private)
예제 #29
0
파일: views.py 프로젝트: jirwin/cyder
def quick_create(request, system_pk):
    # TODO, make sure the user has access to this system
    system = get_object_or_404(System, pk=system_pk)
    if request.method == 'POST':
        interface_form = StaticInterfaceQuickForm(request.POST)

        a, ptr, r = None, None, None
        if interface_form.is_valid():
            try:
                #mac = interface_form.cleaned_data['mac']
                if 'label' in interface_form.cleaned_data:
                    label = interface_form.cleaned_data['label']
                else:
                    label = ""
                mrange_pk = interface_form.cleaned_data['range']
                mrange = get_object_or_404(Range, pk=mrange_pk)
                network = mrange.network
                ip_type = network.ip_type
                vlan = network.vlan
                site = network.site

                networks = []
                for network in vlan.network_set.all():
                    if not network.site:
                        continue
                    if network.site.get_site_path() == site.get_site_path():
                        networks.append(network)
                if not networks:
                    raise ValidationError(
                        "No appropriate networks found. "
                        "Consider adding this interface manually.")

                ip = mrange.get_next_ip()
                if ip is None:
                    raise ValidationError(
                        "No appropriate IP found in {0} Vlan {1} "
                        "Range {2} - {3}. Consider adding this interface "
                        "manually.".format(site.name, vlan.name,
                                           mrange.start_str, mrange.end_str))

                expected_name = "{0}.{1}.mozilla.com".format(
                    vlan.name, site.get_site_path())
                try:
                    domain = Domain.objects.get(name=expected_name)
                except ObjectDoesNotExist, e:
                    raise ValidationError(
                        "The domain '{0}' doesn't seem to exist. "
                        "Consider creating this interface "
                        "manually.".format(expected_name))

                intr = StaticInterface(label=label,
                                       domain=domain,
                                       ip_str=str(ip),
                                       ip_type=ip_type,
                                       system=system)
                intr.full_clean()
                intr.save()
            except ValidationError, e:
                interface_form._errors['__all__'] = ErrorList(e.messages)
                return render(
                    request, 'static_intr/static_intr_form.html', {
                        'form':
                        interface_form,
                        'form_title':
                        "Quick Interface Create for System "
                        "{0}".format(system)
                    })
예제 #30
0
    def test1_freeip(self):
        start_str = "10.0.33.1"
        end_str = "10.0.33.3"
        default_domain = self.d
        network = self.s
        rtype = 's'
        ip_type = '4'
        system = System()

        kwargs = {'start_str': start_str, 'end_str': end_str,
                  'default_domain': default_domain, 'network': network,
                  'rtype': rtype, 'ip_type': ip_type}
        r = self.do_add(**kwargs)
        self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
        self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
        s = StaticInterface(label="foo", domain=self.d, ip_type='4',
                            ip_str=str(r.get_next_ip()), system=system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()
        self.assertEqual(str(r.get_next_ip()), "10.0.33.2")
        s = StaticInterface(label="foo", domain=self.d, ip_type='4',
                            ip_str=str(r.get_next_ip()), system=system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()
        self.assertEqual(str(r.get_next_ip()), "10.0.33.3")
        s = StaticInterface(label="foo", domain=self.d, ip_type='4',
                            ip_str=str(r.get_next_ip()), system=system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()
        self.assertEqual(r.get_next_ip(), None)
예제 #31
0
파일: system_api.py 프로젝트: Ziaunys/chili
    def process_extra(self, bundle, request, **kwargs):
        patch_dict = json.loads(request.POST.items()[0][0])

        if 'delete_interface' in patch_dict and 'interface' in patch_dict:
            patch_dict.pop('delete_interface')
            sys = bundle.obj
            interface = patch_dict.pop('interface', None)
            if sys and interface:
                sys.delete_adapter(interface)

        if 'update_interface' in patch_dict and 'interface' in patch_dict:
            patch_dict.pop('update_interface')
            sys = bundle.obj
            if 'interface' in patch_dict:
                sys.update_adapter(**patch_dict)

        ## Entry point for adding a new adapter by mac address via the rest API
        if 'mac' in patch_dict:

            enable_dns = True
            enable_private = True
            enable_public = False
            sys = bundle.obj
            range = patch_dict.pop('range', None)
            fqdn = patch_dict.pop('fqdn', None)
            ip_str = patch_dict.pop('ip_address', None)
            interface = patch_dict.pop('interface', None)
            domain = patch_dict.pop('domain', 'mozilla.com')
            from cyder.cydhcp.lib.utils import create_ipv4_intr_from_range
            mac = patch_dict['mac']
            if interface:
                interface_type, primary, alias = SystemResource.extract_nic_attrs(
                    interface)
            else:
                interface_type, primary, alias = sys.get_next_adapter()

            if not fqdn:
                domain_parsed = ".".join(
                    sys.hostname.split('.')[1:]) + '.' + domain
                domain_name = domain_parsed.lower()
                label = sys.hostname.split('.')[0]
            else:
                domain_parsed = ".".join(fqdn.split('.')[1:])
                domain_name = domain_parsed.lower()
                label = fqdn.split('.')[0]

            if range:
                range_start_str = range.split(',')[0]
                range_end_str = range.split(',')[1]
                s, errors = create_ipv4_intr_from_range(
                    label, domain_name, sys, mac, range_start_str,
                    range_end_str)
            if ip_str:
                domain = Domain.objects.filter(name=domain_parsed)[0]
                s = StaticInterface(label=label,
                                    mac=mac,
                                    domain=domain,
                                    ip_str=ip_str,
                                    ip_type='4',
                                    system=sys)
            try:
                if s:
                    s.save()
                    s.update_attrs()
                    if enable_dns and enable_public:
                        private = View.objects.get(name='private')
                        s.views.add(private)
                        s.save()

                    elif enable_dns and enable_private and not enable_public:
                        private = View.objects.get(name='private')
                        s.views.add(private)
                        s.save()

                    if interface:
                        interface_type, primary, alias = SystemResource.extract_nic_attrs(
                            interface)
                    else:
                        interface_type, primary, alias = sys.get_next_adapter()

                    s.attrs.primary = primary
                    s.attrs.interface_type = interface_type
                    s.attrs.alias = alias
                else:
                    print 'We failed'
                    bundle.errors[
                        'error_message'] = "Unable to create adapter for unknown reason"
                    raise ValidationError(join(e.messages))
            except ValidationError, e:
                bundle.errors['error_message'] = " ".join(e.messages)
                raise ValidationError(join(e.messages))
            except Exception, e:
                print e
예제 #32
0
파일: ipv4_tests.py 프로젝트: jirwin/cyder
    def test1_freeip(self):
        start_str = "10.0.33.1"
        end_str = "10.0.33.3"
        default_domain = self.d
        network = self.s
        rtype = 's'
        ip_type = '4'
        system = System()

        kwargs = {
            'start_str': start_str,
            'end_str': end_str,
            'default_domain': default_domain,
            'network': network,
            'rtype': rtype,
            'ip_type': ip_type
        }
        r = self.do_add(**kwargs)
        self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
        self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
        s = StaticInterface(label="foo",
                            domain=self.d,
                            ip_type='4',
                            ip_str=str(r.get_next_ip()),
                            system=system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()
        self.assertEqual(str(r.get_next_ip()), "10.0.33.2")
        s = StaticInterface(label="foo",
                            domain=self.d,
                            ip_type='4',
                            ip_str=str(r.get_next_ip()),
                            system=system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()
        self.assertEqual(str(r.get_next_ip()), "10.0.33.3")
        s = StaticInterface(label="foo",
                            domain=self.d,
                            ip_type='4',
                            ip_str=str(r.get_next_ip()),
                            system=system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()
        self.assertEqual(r.get_next_ip(), None)
예제 #33
0
 def do_add(self, mac, label, domain, ip_str, system, ip_type="4"):
     r = StaticInterface(mac=mac, label=label, domain=domain, ip_str=ip_str, ip_type=ip_type, system=system)
     r.clean()
     r.save()
     return r
예제 #34
0
파일: dns_migrate.py 프로젝트: jirwin/cyder
    def gen_static(self):
        """
        Generates the Static Interface objects related to this zone's domain.

        .. note::
            Every static interface needs a system.

        :System uniqueness: hostname, mac, ip_str

        :StaticInterface uniqueness: hostname, mac, ip_str
        """
        cursor.execute("SELECT id, ip, name, workgroup, enabled, ha, "
                       "type, os, location, department , serial, other_id, "
                       "purchase_date, po_number, warranty_date, owning_unit, "
                       "user_id "
                       "FROM host "
                       "WHERE ip != 0 AND domain = '%s';" % self.domain_id)
        for id, ip, name, workgroup, enabled, ha, type, os, location, dept, \
                serial, other_id, purchase_date, po_number, warranty_date, \
                owning_unit, user_id in cursor.fetchall():
            name = name.lower()
            enabled = bool(enabled)
            if ip == 0:
                continue

            if len(ha) != 12:
                ha = "0" * 12

            # TODO: Make systems unique by hostname, ip, mac tuple
            # TODO: Add key-value attributes to system objects.

            system, _ = System.objects.get_or_create(name=name,
                                                     location=location,
                                                     department=dept)
            try:
                cursor.execute("SELECT name "
                               "FROM workgroup"
                               "WHERE id = {0}".format(workgroup))
                name = cursor.fetchone()[0]
                w, _ = Workgroup.objects.get_or_create(name=name)
                v, _ = Vrf.objects.get_or_create(name="{0}-".format(name))
            except:
                v = None
                w = None

            if not (StaticInterface.objects.filter(
                    label=name, mac=clean_mac(ha),
                    ip_str=long2ip(ip)).exists()):
                try:
                    static = StaticInterface(label=name,
                                             domain=self.domain,
                                             mac=clean_mac(ha),
                                             system=system,
                                             ip_str=long2ip(ip),
                                             ip_type='4',
                                             vrf=v,
                                             workgroup=w)

                    # Static Interfaces need to be cleaned independently.
                    # (no get_or_create)
                    static.full_clean()
                    static.save()
                    if enabled:
                        static.views.add(public)
                    cursor.execute("SELECT dhcp_option, value "
                                   "FROM object_option "
                                   "WHERE object_id = {0} "
                                   "AND type = 'host'".format(id))
                    results = cursor.fetchall()
                    for dhcp_option, value in results:
                        cursor.execute("SELECT name, type "
                                       "FROM dhcp_options "
                                       "WHERE id = {0}".format(dhcp_option))
                        name, type = cursor.fetchone()
                        kv = StaticIntrKeyValue(intr=static,
                                                key=name,
                                                value=value)
                        kv.clean()
                        kv.save()
                except ValidationError, e:
                    print "Error generating static interface. %s" % e
                    exit(1)
예제 #35
0
파일: views.py 프로젝트: Ziaunys/chili
def quick_create(request, system_pk):
    # TODO, make sure the user has access to this system
    system = get_object_or_404(System, pk=system_pk)
    if request.method == 'POST':
        interface_form = StaticInterfaceQuickForm(request.POST)

        a, ptr, r = None, None, None
        if interface_form.is_valid():
            try:
                #mac = interface_form.cleaned_data['mac']
                if 'label' in interface_form.cleaned_data:
                    label = interface_form.cleaned_data['label']
                else:
                    label = ""
                mrange_pk = interface_form.cleaned_data['range']
                mrange = get_object_or_404(Range, pk=mrange_pk)
                network = mrange.network
                ip_type = network.ip_type
                vlan = network.vlan
                site = network.site

                networks = []
                for network in vlan.network_set.all():
                    if not network.site:
                        continue
                    if network.site.get_site_path() == site.get_site_path():
                        networks.append(network)
                if not networks:
                    raise ValidationError("No appropriate networks found. "
                                          "Consider adding this interface manually.")

                ip = mrange.get_next_ip()
                if ip is None:
                    raise ValidationError("No appropriate IP found "
                                          "in {0} Vlan {1} Range {2} - {3}. Consider adding "
                                          "this interface manually.".format(site.name, vlan.name,
                                                                            mrange.start_str, mrange.end_str))

                expected_name = "{0}.{1}.mozilla.com".format(vlan.name,
                                                             site.get_site_path())
                print "Expected name {0}".format(expected_name)
                try:
                    domain = Domain.objects.get(name=expected_name)
                except ObjectDoesNotExist, e:
                    raise ValidationError("The domain '{0}' doesn't seem to "
                                          "exist. Consider creating this interface "
                                          "manually.".format(expected_name))

                intr = StaticInterface(label=label, domain=domain,
                                       ip_str=str(ip),
                                       #ip_type=ip_type, mac=mac, system=system)
                                       ip_type=ip_type, system=system)
                intr.full_clean()
                intr.save()
            except ValidationError, e:
                interface_form._errors['__all__'] = ErrorList(e.messages)
                return render(request, 'static_intr/static_intr_form.html', {
                    'form': interface_form,
                    'form_title': "Quick Interface Create for System "
                    "{0}".format(system)
                })
예제 #36
0
    def test_private_view_case_3_intr(self):
        intr = StaticInterface(
            label="asf3", domain=self.f_o, ip_str="10.0.0.1",
            ip_type="4", mac="01:11:22:33:44:55", system=self.s)
        intr.clean()
        intr.save()
        intr.views.add(self.private)
        intr.save()
        # Object has to exist before views can be assigned.
        intr.views.add(self.public)
        self.assertFalse(intr.views.filter(name="public"))

        intr = StaticInterface(
            label="asf3", domain=self.f_o, ip_str="172.31.255.254",
            ip_type="4", mac="01:11:22:33:44:55", system=self.s)
        intr.clean()
        intr.save()
        intr.views.add(self.private)
        intr.save()
        # Object has to exist before views can be assigned.
        intr.views.add(self.public)
        self.assertFalse(intr.views.filter(name="public"))

        intr = StaticInterface(label="asf3", domain=self.f_o,
                               ip_str="192.168.255.254",
                               ip_type="4", mac="01:11:22:33:44:55", system=self.s)
        intr.clean()
        intr.save()
        intr.views.add(self.private)
        intr.save()
        # Object has to exist before views can be assigned.
        intr.views.add(self.public)
        self.assertFalse(intr.views.filter(name="public"))
예제 #37
0
파일: system_api.py 프로젝트: Ziaunys/chili
    def process_extra(self, bundle, request, **kwargs):
        patch_dict = json.loads(request.POST.items()[0][0])

        if 'delete_interface' in patch_dict and 'interface' in patch_dict:
            patch_dict.pop('delete_interface')
            sys = bundle.obj
            interface = patch_dict.pop('interface', None)
            if sys and interface:
                sys.delete_adapter(interface)

        if 'update_interface' in patch_dict and 'interface' in patch_dict:
            patch_dict.pop('update_interface')
            sys = bundle.obj
            if 'interface' in patch_dict:
                sys.update_adapter(**patch_dict)

        ## Entry point for adding a new adapter by mac address via the rest API
        if 'mac' in patch_dict:

            enable_dns = True
            enable_private = True
            enable_public = False
            sys = bundle.obj
            range = patch_dict.pop('range', None)
            fqdn = patch_dict.pop('fqdn', None)
            ip_str = patch_dict.pop('ip_address', None)
            interface = patch_dict.pop('interface', None)
            domain = patch_dict.pop('domain', 'mozilla.com')
            from cyder.cydhcp.lib.utils import create_ipv4_intr_from_range
            mac = patch_dict['mac']
            if interface:
                interface_type, primary, alias = SystemResource.extract_nic_attrs(interface)
            else:
                interface_type, primary, alias = sys.get_next_adapter()

            if not fqdn:
                domain_parsed = ".".join(
                    sys.hostname.split('.')[1:]) + '.' + domain
                domain_name = domain_parsed.lower()
                label = sys.hostname.split('.')[0]
            else:
                domain_parsed = ".".join(fqdn.split('.')[1:])
                domain_name = domain_parsed.lower()
                label = fqdn.split('.')[0]

            if range:
                range_start_str = range.split(',')[0]
                range_end_str = range.split(',')[1]
                s, errors = create_ipv4_intr_from_range(label, domain_name, sys, mac, range_start_str, range_end_str)
            if ip_str:
                domain = Domain.objects.filter(name=domain_parsed)[0]
                s = StaticInterface(label=label, mac=mac, domain=domain,
                                    ip_str=ip_str, ip_type='4', system=sys)
            try:
                if s:
                    s.save()
                    s.update_attrs()
                    if enable_dns and enable_public:
                        private = View.objects.get(name='private')
                        s.views.add(private)
                        s.save()

                    elif enable_dns and enable_private and not enable_public:
                        private = View.objects.get(name='private')
                        s.views.add(private)
                        s.save()

                    if interface:
                        interface_type, primary, alias = SystemResource.extract_nic_attrs(interface)
                    else:
                        interface_type, primary, alias = sys.get_next_adapter()

                    s.attrs.primary = primary
                    s.attrs.interface_type = interface_type
                    s.attrs.alias = alias
                else:
                    print 'We failed'
                    bundle.errors['error_message'] = "Unable to create adapter for unknown reason"
                    raise ValidationError(join(e.messages))
            except ValidationError, e:
                bundle.errors['error_message'] = " ".join(e.messages)
                raise ValidationError(join(e.messages))
            except Exception, e:
                print e
예제 #38
0
 def do_add(self, mac, label, domain, ip_str, ip_type='4'):
     r = StaticInterface(mac=mac,
                         label=label,
                         domain=domain,
                         ip_str=ip_str,
                         ip_type=ip_type,
                         system=self.n)
     r.clean()
     r.save()
     r.details()
     r.get_update_url()
     r.get_delete_url()
     r.get_detail_url()
     repr(r)
     return r
예제 #39
0
    def gen_static(self):
        """
        Generates the Static Interface objects related to this zone's domain.

        .. note::
            Every static interface needs a system.

        :System uniqueness: hostname, mac, ip_str

        :StaticInterface uniqueness: hostname, mac, ip_str
        """
        cursor.execute(
            "SELECT id, ip, name, workgroup, enabled, ha, "
            "type, os, location, department , serial, other_id, "
            "purchase_date, po_number, warranty_date, owning_unit, "
            "user_id "
            "FROM host "
            "WHERE ip != 0 AND domain = '%s';" % self.domain_id
        )
        for (
            id,
            ip,
            name,
            workgroup,
            enabled,
            ha,
            type,
            os,
            location,
            dept,
            serial,
            other_id,
            purchase_date,
            po_number,
            warranty_date,
            owning_unit,
            user_id,
        ) in cursor.fetchall():
            name = name.lower()
            enabled = bool(enabled)
            if ip == 0:
                continue

            if len(ha) != 12:
                ha = "0" * 12

            # TODO: Make systems unique by hostname, ip, mac tuple
            # TODO: Add key-value attributes to system objects.

            system, _ = System.objects.get_or_create(name=name, location=location, department=dept)
            try:
                cursor.execute("SELECT name " "FROM workgroup" "WHERE id = {0}".format(workgroup))
                name = cursor.fetchone()[0]
                w, _ = Workgroup.objects.get_or_create(name=name)
                v, _ = Vrf.objects.get_or_create(name="{0}-".format(name))
            except:
                v = None
                w = None

            if not (StaticInterface.objects.filter(label=name, mac=clean_mac(ha), ip_str=long2ip(ip)).exists()):
                try:
                    static = StaticInterface(
                        label=name,
                        domain=self.domain,
                        mac=clean_mac(ha),
                        system=system,
                        ip_str=long2ip(ip),
                        ip_type="4",
                        vrf=v,
                        workgroup=w,
                    )

                    # Static Interfaces need to be cleaned independently.
                    # (no get_or_create)
                    static.full_clean()
                    static.save()
                    if enabled:
                        static.views.add(public)
                    cursor.execute(
                        "SELECT dhcp_option, value "
                        "FROM object_option "
                        "WHERE object_id = {0} "
                        "AND type = 'host'".format(id)
                    )
                    results = cursor.fetchall()
                    for dhcp_option, value in results:
                        cursor.execute("SELECT name, type " "FROM dhcp_options " "WHERE id = {0}".format(dhcp_option))
                        name, type = cursor.fetchone()
                        kv = StaticIntrKeyValue(intr=static, key=name, value=value)
                        kv.clean()
                        kv.save()
                except ValidationError, e:
                    print "Error generating static interface. %s" % e
                    exit(1)
예제 #40
0
    def gen_static(self):
        """
        Generates the Static Interface objects related to this zone's domain.

        .. note::
            Every static interface needs a system.

        :System uniqueness: hostname, mac, ip_str

        :StaticInterface uniqueness: hostname, mac, ip_str
        """
        from dhcp_migrate import migrate_zones

        if Ctnr.objects.count() <= 2:
            print "WARNING: Zones not migrated. Attempting to migrate now."
            migrate_zones()

        sys_value_keys = {
            "type": "Hardware Type",
            "os": "Operating System",
            "location": "Location",
            "department": "Department",
            "serial": "Serial Number",
            "other_id": "Other ID",
            "purchase_date": "Purchase Date",
            "po_number": "PO Number",
            "warranty_date": "Warranty Date",
            "owning_unit": "Owning Unit",
            "user_id": "User ID"
        }

        keys = ("host.id", "ip", "host.name", "zone.name", "workgroup",
                "enabled", "ha", "zone", "type", "os", "location",
                "department", "serial", "other_id", "purchase_date",
                "po_number", "warranty_date", "owning_unit", "user_id",
                "last_seen", "expire", "ttl", "last_update")

        sql = ("SELECT %s FROM host JOIN zone ON host.zone = zone.id "
               "WHERE ip != 0 AND domain = '%s';" %
               (", ".join(keys), self.domain_id))

        cursor.execute(sql)
        for values in cursor.fetchall():
            items = dict(zip(keys, values))
            ctnr = self.ctnr_from_zone_name(items['zone.name'])
            if ctnr is None:
                continue

            name = items['host.name']
            enabled = bool(items['enabled'])
            dns_enabled, dhcp_enabled = enabled, enabled
            ip = items['ip']
            ha = items['ha']
            if ip == 0:
                continue

            if len(ha) != 12 or ha == '0' * 12:
                ha = ""

            if ha == "":
                dhcp_enabled = False

            # check for duplicate
            static = StaticInterface.objects.filter(label=name,
                                                    mac=(clean_mac(ha)
                                                         or None),
                                                    ip_str=long2ip(ip))
            if static:
                stderr.write("Ignoring host %s: already exists.\n" %
                             items['host.id'])
                continue

            # create system
            system = System(name=name)
            system.save()
            for key in sys_value_keys.keys():
                value = items[key].strip()
                if not value or value == '0':
                    continue
                attr = Attribute.objects.get(
                    name=fix_attr_name(sys_value_keys[key]))
                eav = SystemAV(entity=system, attribute=attr, value=value)
                eav.full_clean()
                eav.save()

            # check for workgroup
            if items['workgroup'] is not None:
                cursor.execute("SELECT name "
                               "FROM workgroup "
                               "WHERE id = {0}".format(items['workgroup']))
                wname = cursor.fetchone()[0]
                w, _ = Workgroup.objects.get_or_create(name=wname)
            else:
                w = None

            last_seen = items['last_seen'] or None
            if last_seen:
                last_seen = datetime.fromtimestamp(last_seen)

            static = StaticInterface(label=name,
                                     domain=self.domain,
                                     mac=(clean_mac(ha) or None),
                                     system=system,
                                     ip_str=long2ip(ip),
                                     ip_type='4',
                                     workgroup=w,
                                     ctnr=ctnr,
                                     ttl=items['ttl'],
                                     dns_enabled=dns_enabled,
                                     dhcp_enabled=dhcp_enabled,
                                     last_seen=last_seen)

            # create static interface
            try:
                static.save(update_range_usage=False)
            except ValidationError as e:
                try:
                    static.dhcp_enabled = False
                    static.dns_enabled = dns_enabled
                    static.save(update_range_usage=False)
                    stderr.write('WARNING: Static interface with IP {} has '
                                 'been disabled\n'.format(static.ip_str))
                    stderr.write('    {}\n'.format(e))
                except ValidationError as e:
                    stderr.write('WARNING: Could not create static interface '
                                 'with IP {}\n'.format(static.ip_str))
                    stderr.write('    {}\n'.format(e))
                    static = None
                    system.delete()

            if static:
                static.views.add(public)
                static.views.add(private)
예제 #41
0
    def testtest_add_ns_in_domain_intr(self):
        # Use an Interface as a glue record.
        glue = StaticInterface(label='ns232',
                               domain=self.r,
                               ip_str='128.193.99.10',
                               ip_type='4',
                               system=self.s,
                               mac="12:23:45:45:45:45")
        glue.clean()
        glue.save()
        data = {'domain': self.r, 'server': 'ns232.ru'}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.server, ns.glue.fqdn)
        self.assertRaises(ValidationError, glue.delete)

        glue = StaticInterface(label='ns332',
                               domain=self.f_r,
                               ip_str='128.193.1.10',
                               ip_type='4',
                               system=self.s,
                               mac="11:22:33:44:55:66")
        glue.clean()
        glue.save()
        data = {'domain': self.f_r, 'server': 'ns332.foo.ru'}
        ns = self.do_add(**data)
        self.assertTrue(ns.glue)
        self.assertEqual(ns.server, ns.glue.fqdn)
예제 #42
0
파일: basic.py 프로젝트: alecdhuse/cyder
 def do_add(self, mac, label, domain, ip_str, ip_type='4'):
     r = StaticInterface(mac=mac, label=label, domain=domain, ip_str=ip_str,
                         ip_type=ip_type, system=self.n)
     r.clean()
     r.save()
     r.details()
     r.get_update_url()
     r.get_delete_url()
     r.get_detail_url()
     repr(r)
     return r
예제 #43
0
    def test6_create_ipv4_interface(self):
        v, _ = Vlan.objects.get_or_create(name="6db", number=3)
        s, _ = Site.objects.get_or_create(name="6scl3")
        d, _ = Domain.objects.get_or_create(name="6scl3.mozilla.com")
        d, _ = Domain.objects.get_or_create(name="6db.6scl3.mozilla.com")
        d, _ = Domain.objects.get_or_create(name="arpa")
        d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
        d, _ = Domain.objects.get_or_create(name="11.in-addr.arpa")
        n = Network(network_str="11.0.0.0/8", ip_type="4")
        n.clean()
        n.site = s
        n.vlan = v
        n.save()

        r = Range(start_str="11.0.0.0",
                  end_str="11.0.0.2",
                  network=n,
                  ip_type='4')
        r.clean()
        r.save()

        s = StaticInterface(label="fab",
                            domain=d,
                            ip_type="4",
                            ip_str="11.0.0.0",
                            system=self.system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()

        s = StaticInterface(label="fab",
                            domain=d,
                            ip_type="4",
                            ip_str="11.0.0.1",
                            system=self.system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()

        s = StaticInterface(label="fab",
                            domain=d,
                            ip_type="4",
                            ip_str="11.0.0.2",
                            system=self.system,
                            mac="00:00:00:00:00:00")
        s.clean()
        s.save()

        intr, errors = create_ipv4_interface("foo", "6db", "6scl3",
                                             self.system, "11:22:33:44:55:66",
                                             "mozilla.com")
        self.assertEqual(intr, None)
        self.assertTrue("vlan" not in errors)
        self.assertTrue("site" not in errors)
        self.assertTrue("domain" not in errors)
        self.assertTrue("network" not in errors)
        self.assertTrue("range" not in errors)
        self.assertTrue("ip" in errors)
예제 #44
0
    def test6_create_ipv4_interface(self):
        v, _ = Vlan.objects.get_or_create(name="6db", number=3)
        s, _ = Site.objects.get_or_create(name="6scl3")
        d, _ = Domain.objects.get_or_create(name="6scl3.mozilla.com")
        d, _ = Domain.objects.get_or_create(name="6db.6scl3.mozilla.com")
        d, _ = Domain.objects.get_or_create(name="arpa")
        d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
        d, _ = Domain.objects.get_or_create(name="11.in-addr.arpa")
        n = Network(network_str="11.0.0.0/8", ip_type="4")
        n.clean()
        n.site = s
        n.vlan = v
        n.save()

        r = Range(start_str="11.0.0.0", end_str="11.0.0.2",
                  network=n)
        r.clean()
        r.save()

        s = StaticInterface(label="fab", domain=d, ip_type="4",
                            ip_str="11.0.0.0", system=self.system, mac="00:00:00:00:00:00")
        s.clean()
        s.save()

        s = StaticInterface(label="fab", domain=d, ip_type="4",
                            ip_str="11.0.0.1", system=self.system, mac="00:00:00:00:00:00")
        s.clean()
        s.save()

        s = StaticInterface(label="fab", domain=d, ip_type="4",
                            ip_str="11.0.0.2", system=self.system, mac="00:00:00:00:00:00")
        s.clean()
        s.save()

        intr, errors = create_ipv4_interface(
            "foo", "6db", "6scl3", self.system,
            "11:22:33:44:55:66", "mozilla.com")
        self.assertEqual(intr, None)
        self.assertTrue("vlan" not in errors)
        self.assertTrue("site" not in errors)
        self.assertTrue("domain" not in errors)
        self.assertTrue("network" not in errors)
        self.assertTrue("range" not in errors)
        self.assertTrue("ip" in errors)