def run(self):
src, dest = self.settings.src, self.settings.dest
dest_at_src = self.settings.dest_at_src
do_import = self.settings.do_import
temp_dir = None
if src.split("/")[-1].endswith(".ldif"): # ldif as input file
if dest_at_src:
dest = "{}/couch".format(path.dirname(src))
map(unlink, [path.join(dest, f) for f in listdir(dest)])
else:
temp_dir = tempfile.mkdtemp()
dest = "{}/couch".format(temp_dir)
if not path.isdir(dest):
mkdir(dest)
self.create_files(dest=dest, src=src)
json_src = dest
else:
json_src = src # for json dir as input files
if do_import:
couch_up = CouchdbUploader(
path=json_src, couchdb_uri=self.settings.couchdb_uri,
couchdb_db=self.settings.couchdb_db
)
for fname in listdir(json_src):
couch_up.put(
data="@{}".format(fname),
doc_id=fname[:-5]
)
create_order_doc(couch_up)
if temp_dir:
shutil.rmtree(temp_dir)
def run(self):
couch_up = CouchdbUploader(
path=self.settings.path, couchdb_uri=self.settings.couchdb_uri,
couchdb_db=self.settings.couchdb_db
)
for fname in os.listdir(self.settings.path):
couch_up.put(
data="@{}".format(fname),
doc_id=fname[:-5]
)
def create_files(self):
self.create_docs()
if os.path.exists(self.dest):
shutil.rmtree(self.dest)
os.mkdir(self.dest)
json_files = FilesForCouch(self.docs, self.dest)
json_files.create()
if not self.settings.only_files:
couch_up = CouchdbUploader(
path=self.dest, couchdb_uri=self.settings.couchdb_uri, couchdb_db=self.settings.couchdb_db
)
for fname in os.listdir(self.dest):
couch_up.put(data="@{}".format(fname), doc_id=fname[:-5])
def setUp(self):
self.settings = {
"couchdb_uri": "http://*****:*****@cdb:5984",
"couchdb_db": "desk_tester",
}
s = Server(self.settings["couchdb_uri"])
self.s = s
s.create_db(self.settings['couchdb_db'])
self.up = CouchdbUploader(path=os.path.dirname(__file__), auth=('admin', 'admin'), **self.settings)
def setUp(self):
self.db_conf = {
"couchdb_uri": "http://*****:*****@cdb:5984",
"couchdb_db": "desk_tester",
}
self.conf = {
"powerdns_backend": "sqlite",
"powerdns_db": "/var/services/data/powerdns/pdns_dnsa.test.sqlite3",
"powerdns_name": "dnsa.test",
"powerdns_primary": "dnsa.test",
"worker_is_foreman": True,
}
self.conf.update(self.db_conf)
s = Server(self.db_conf["couchdb_uri"])
self.s = s
s.create_db(self.db_conf['couchdb_db'])
self.db = self.s.get_db(self.db_conf["couchdb_db"])
self.couch_up = CouchdbUploader(
path=os.path.dirname(__file__),
auth=('admin', 'admin'), **self.db_conf
)
status_code = self.couch_up.put(
data="@fixtures/couchdb-design.json",
doc_id="_design/{couchdb_db}"
)
if not status_code == 201:
s.delete_db(self.db_conf["couchdb_db"])
worker_id = "worker-foreman"
d = {
"_id": worker_id, "type": "worker", "hostname": "foreman",
"provides": {
"domain": [{"backend": "powerdns", "name": "dnsa.test"}]
}
}
self.assertTrue(
self.couch_up.put(data=json.dumps(d), doc_id=worker_id) == 201
)
self.assertTrue(
self.couch_up.put(data="@fixtures/couchdb-template-dns.json",
doc_id="template-email") == 201
)
self.assertTrue(
self.couch_up.put(data="@fixtures/couchdb-map-ips.json",
doc_id="map-ips") == 201
)
class UtilTestCase(unittest.TestCase):
def setUp(self):
self.settings = {
"couchdb_uri": "http://*****:*****@cdb:5984",
"couchdb_db": "desk_tester",
}
s = Server(self.settings["couchdb_uri"])
self.s = s
s.create_db(self.settings['couchdb_db'])
self.up = CouchdbUploader(path=os.path.dirname(__file__), auth=('admin', 'admin'), **self.settings)
def tearDown(self):
self.s.delete_db(self.settings["couchdb_db"])
def test_broken_json(self):
json = """ { "_id": "broken-json", "type": "worker", "hostname": "tworkerbroken", } """ # no ","
status_code = self.up.put(data=json, doc_id="broken-json")
self.assertTrue(status_code == 400)
class WorkerTestCase(unittest.TestCase):
def setUp(self):
self.db_conf = {
"couchdb_uri": "http://*****:*****@cdb:5984",
"couchdb_db": "desk_tester",
}
self.conf = {
"powerdns_backend": "sqlite",
"powerdns_db": "/var/services/data/powerdns/pdns_dnsa.test.sqlite3",
"powerdns_name": "dnsa.test",
"powerdns_primary": "dnsa.test",
"worker_is_foreman": True,
}
self.conf.update(self.db_conf)
s = Server(self.db_conf["couchdb_uri"])
self.s = s
s.create_db(self.db_conf['couchdb_db'])
self.db = self.s.get_db(self.db_conf["couchdb_db"])
self.couch_up = CouchdbUploader(
path=os.path.dirname(__file__),
auth=('admin', 'admin'), **self.db_conf
)
status_code = self.couch_up.put(
data="@fixtures/couchdb-design.json",
doc_id="_design/{couchdb_db}"
)
if not status_code == 201:
s.delete_db(self.db_conf["couchdb_db"])
worker_id = "worker-foreman"
d = {
"_id": worker_id, "type": "worker", "hostname": "foreman",
"provides": {
"domain": [{"backend": "powerdns", "name": "dnsa.test"}]
}
}
self.assertTrue(
self.couch_up.put(data=json.dumps(d), doc_id=worker_id) == 201
)
self.assertTrue(
self.couch_up.put(data="@fixtures/couchdb-template-dns.json",
doc_id="template-email") == 201
)
self.assertTrue(
self.couch_up.put(data="@fixtures/couchdb-map-ips.json",
doc_id="map-ips") == 201
)
def tearDown(self):
has_domain1, has_domain2 = (
Powerdns(ObjectDict(**self.conf)).check_domain("test"),
Powerdns(ObjectDict(**self.conf)).check_domain("test2")
)
self._remove_domain("test") if has_domain1 else None
self._remove_domain("test2") if has_domain2 else None
self.s.delete_db(self.db_conf["couchdb_db"])
def _run_order(self):
self._run_worker(is_foreman=True)
def _run_worker(self, is_foreman=True):
conf = self.conf
w = Foreman(conf, hostname="foreman")
w.run_once()
def _get_dns_validator(self, doc_id, lookup={
'dnsa.test': "127.0.0.1",
'dnsb.test': "127.0.0.1"
}):
doc = MergedDoc(self.db, self.db.get(doc_id)).doc
validator = DnsValidator(doc, lookup=lookup)
return validator
def _create_order_doc(self):
current_time = time.localtime()
order_id = "order-{}-{}".format(int(time.mktime(current_time)),
self.s.next_uuid())
order_doc = {
"_id": order_id,
"date": time.strftime("%Y-%m-%d %H:%M:%S %z", current_time),
"type": "order", "sender": "pad", "state": "new_pre"
}
self.assertTrue(self.couch_up.put(data=json.dumps(order_doc),
doc_id=order_id) == 201)
self.assertTrue(self.couch_up.update(handler='add-editor',
doc_id=order_id) == 201)
return order_id
def _add_domain_test_tt(self, run=True, add_order=True):
dns_id = "dns-test"
self.assertTrue(self.couch_up.put(data="@fixtures/couchdb-dns-test.json",
doc_id=dns_id) == 201)
self.assertTrue(self.couch_up.update(handler='add-editor',
doc_id=dns_id) == 201)
order_id = None
if run and add_order:
order_id = self._create_order_doc()
self._run_order()
return (dns_id, order_id)
def _add_domain_test2_tt(self, run=True, add_order=True):
dns_id = "dns-test2"
self.assertTrue(self.couch_up.put(data="@fixtures/couchdb-dns-test2.json",
doc_id=dns_id) == 201)
self.assertTrue(self.couch_up.update(handler='add-editor',
doc_id=dns_id) == 201)
order_id = None
if run and add_order:
order_id = self._create_order_doc()
self._run_order()
return (dns_id, order_id)
def _remove_domain(self, domain, docs=None):
# cleanup
pdns = Powerdns(ObjectDict(**self.conf))
pdns.del_domain(domain)
if docs:
self.db.delete_doc(docs)
def test_worker_settings(self):
doc = self.db.get("worker-foreman")
self.assertTrue(doc['provides']['domain'][0]["backend"] == "powerdns")
def test_new_domain(self):
dns_id, order_id = self._add_domain_test_tt()
self.assertTrue(self.db.get(dns_id)['state'] == 'active')
self.assertTrue(self._get_dns_validator('dns-test').do_check())
self._remove_domain('test', docs=[dns_id, order_id])
def test_update_record(self):
dns_id, order_id = self._add_domain_test_tt()
dns_doc = self.db.get(dns_id)
dns_doc['a'][4]['ip'] = "1.1.1.21"
dns_doc['a'][1]['host'] = "ns3"
dns_doc['cname'][0]['host'] = "dnsa"
VersionDoc(self.db, dns_doc).create_version()
order_id = self._create_order_doc()
self._run_order()
self.assertTrue(self.db.get(dns_id)['state'] == 'active')
self.assertTrue(self._get_dns_validator('dns-test').do_check())
self._remove_domain('test', docs=[dns_id, order_id])
def test_complete_change_record(self):
dns_id, order_id = self._add_domain_test_tt()
dns_doc = self.db.get(dns_id)
changed_a = copy(dns_doc['a'][4])
dns_doc['a'][4]['ip'] = "1.1.1.21"
dns_doc['a'][4]['host'] = "www2"
VersionDoc(self.db, dns_doc).create_version()
order_id = self._create_order_doc()
self._run_order()
self.assertTrue(self.db.get(dns_id)['state'] == 'active')
with self.assertRaises(NXDOMAIN):
self._get_dns_validator('dns-test').check_one_record(
'A', 'ip', q_key='host', item=changed_a
)
self.assertTrue(self._get_dns_validator('dns-test').do_check())
self._remove_domain('test', docs=[dns_id, order_id])
def test_append_record(self):
dns_id, order_id = self._add_domain_test_tt()
dns_doc = self.db.get(dns_id)
dns_doc['a'].append({'host': "forum", 'ip': "1.1.1.25"})
dns_doc['cname'].append({'alias': "super", 'host': "www"})
VersionDoc(self.db, dns_doc).create_version()
order_id = self._create_order_doc()
self._run_order()
self.assertTrue(self.db.get(dns_id)['state'] == 'active')
self.assertTrue(self._get_dns_validator('dns-test').do_check())
self._remove_domain('test', docs=[dns_id, order_id])
def test_delete_record(self):
dns_id, order1_id = self._add_domain_test_tt()
dns_doc = self.db.get(dns_id)
removed_a = dns_doc['a'].pop(4)
vd = VersionDoc(self.db, dns_doc)
vd.create_version()
order2_id = self._create_order_doc()
self._run_order()
self.assertTrue(self.db.get(dns_id)['state'] == 'active')
with self.assertRaises(NXDOMAIN):
self._get_dns_validator('dns-test').check_one_record(
'A', 'ip', q_key='host', item=removed_a
)
self._remove_domain('test', docs=[dns_id, order1_id, order2_id])
def test_two_domains(self):
ddnsa_id, order_id = self._add_domain_test_tt(run=False, add_order=False)
ddnsb_id, order_id = self._add_domain_test2_tt(run=False, add_order=False)
order1_id = self._create_order_doc()
self._run_order()
self.assertTrue(self.db.get(ddnsa_id)['state'] == 'active')
self.assertTrue(self._get_dns_validator('dns-test').do_check())
self.assertTrue(self.db.get(ddnsb_id)['state'] == 'active')
self.assertTrue(self._get_dns_validator('dns-test2').do_check())
self._remove_domain('test', docs=[ddnsa_id, order1_id])
self._remove_domain('test2', docs=[ddnsb_id])
