def form_valid(self, form):
domain_name = form.cleaned_data.get('domain_name', '').strip().lower()
zmaster.domain_synchronize_from_backend(
domain_name=domain_name,
refresh_contacts=True,
rewrite_contacts=False,
change_owner_allowed=True,
create_new_owner_allowed=True,
soft_delete=True,
raise_errors=True,
log_events=True,
log_transitions=True,
)
domain_in_db = zdomains.domain_find(domain_name=domain_name)
if domain_in_db:
logger.info(f'domain {domain_name} is successfully synchronized')
messages.success(
self.request,
f'Domain {domain_name} is successfully synchronized')
else:
messages.warning(
self.request,
f'Something went wrong during synchronization of {domain_name}'
)
return super().form_valid(form)
def do_domain_expiry_date_updated(domain):
logger.info('domain %s expiry date updated', domain)
try:
zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=False,
change_owner_allowed=False,
)
except zerrors.EPPError:
logger.exception('failed to synchronize domain from back-end: %s' %
domain)
return False
return True
def do_domain_transfer_to_us(domain):
logger.info('domain %s transferred to Zenaida', domain)
try:
zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=True,
change_owner_allowed=True,
)
except zerrors.EPPError:
logger.exception('failed to synchronize domain from back-end: %s' %
domain)
return False
return True
def do_domain_deleted(domain, soft_delete=True, notify=False):
logger.info('domain %s deleted', domain)
try:
zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=False,
change_owner_allowed=True,
soft_delete=soft_delete,
)
except zerrors.EPPError:
logger.exception('failed to synchronize domain from back-end: %s' %
domain)
return False
return True
def do_domain_transfer_away(domain,
from_client=None,
to_client=None,
notify=False):
logger.info('domain %s transferred away', domain)
try:
zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=False,
change_owner_allowed=True,
)
except zerrors.EPPError:
logger.exception('failed to synchronize domain from back-end: %s' %
domain)
return False
return True
def domain_synchronize_from_backend(self, request, queryset):
from zen import zmaster
report = []
for domain_object in queryset:
outputs = zmaster.domain_synchronize_from_backend(
domain_name=domain_object.name,
refresh_contacts=True,
change_owner_allowed=True,
raise_errors=True,
log_events=True,
log_transitions=True,
)
ok = True
for output in outputs:
if isinstance(output, Exception):
report.append('"%s": %r' % (
domain_object.name,
output,
))
ok = False
if ok:
report.append('"%s": %d calls OK' % (
domain_object.name,
len(outputs),
))
self.message_user(request, ', '.join(report))
def sync_expired_domains(dry_run=True):
"""
When domain is expired COCCA back-end suppose to suspend it and send polling notification to Zenaida.
But it is also possible that COCCA move it to another registrar - for example to put it on auction.
In that case notification is not sent for some reason and Zenaida potentially can display wrong information to user.
To workaround that we can keep track of all domains that are just expired few minutes ago and fetch the actual
info from COCCA back-end for those. This way Zenaida will recognize the latest status of the domain and take
required actions: remove domain from Zenaida DB.
"""
moment_now = timezone.now()
expired_active_domains = Domain.domains.filter(
expiry_date__lte=moment_now,
status='active',
).exclude(epp_id=None, )
report = []
for expired_domain in expired_active_domains:
logger.info('domain %r is expired, going to synchronize from back-end',
expired_domain)
if dry_run:
result = []
else:
result = zmaster.domain_synchronize_from_backend(
domain_name=expired_domain.name,
create_new_owner_allowed=False,
domain_transferred_away=True,
soft_delete=False,
)
report.append((
expired_domain,
result,
))
return report
def _do_domain_synchronize_from_backend(self,
queryset,
soft_delete=True,
change_owner_allowed=False):
report = []
for domain_object in queryset:
outputs = []
outputs.extend(
zmaster.domain_synchronize_from_backend(
domain_name=domain_object.name,
refresh_contacts=True,
rewrite_contacts=False,
change_owner_allowed=change_owner_allowed,
create_new_owner_allowed=change_owner_allowed,
soft_delete=soft_delete,
raise_errors=True,
log_events=True,
log_transitions=True,
))
if soft_delete is True:
domain_object.refresh_from_db()
ok = True
for output in outputs:
if isinstance(output, Exception):
report.append('"%s": %r' % (
domain_object.name,
output,
))
ok = False
if ok:
report.append('"%s": %d calls OK' % (
domain_object.name,
len(outputs),
))
return report
def do_domain_transfer_in(domain):
logger.info('domain %s transferred to Zenaida', domain)
try:
outputs = zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=True,
rewrite_contacts=True,
change_owner_allowed=True,
create_new_owner_allowed=True,
)
except rpc_error.EPPError:
logger.exception('failed to synchronize domain %s from back-end' %
domain)
return False
if not outputs:
logger.critical('synchronize domain %s failed with empty result' %
domain)
return False
if not outputs[-1] or isinstance(outputs[-1], Exception):
logger.critical('synchronize domain %s failed with result: %r', domain,
outputs[-1])
return False
logger.info('outputs: %r', outputs)
domain_object = zdomains.domain_find(domain_name=domain)
if not domain_object:
logger.critical(
'synchronize domain %s failed, no domain object found' % domain)
return False
return True
def test_domain_restore():
if os.environ.get('E2E', '0') != '1':
return pytest.skip('skip E2E') # @UndefinedVariable
if os.environ.get('MANUAL', '0') != '1':
return pytest.skip('skip E2E') # @UndefinedVariable
# first need to read existing domain from back-end and create it in local DB
testsupport.prepare_tester_registrant(epp_id='tester087401xo2c',
create_new=True)
zmaster.domain_synchronize_from_backend(
'test-restore-0.ai',
refresh_contacts=True,
change_owner_allowed=False,
soft_delete=False,
)
tester_domain = zdomains.domain_find(domain_name='test-restore-0.ai')
assert tester_domain.epp_id is not None
# now try to restore it
scenario = []
dr = domain_resurrector.DomainResurrector(
log_events=True,
log_transitions=True,
raise_errors=True,
)
dr.add_state_changed_callback(
cb=lambda oldstate, newstate, event, *args, **kwargs: scenario.append((
oldstate,
newstate,
event,
)),
)
dr.event('run', domain_object=tester_domain)
outputs = list(dr.outputs)
del dr
# this domain must be restored now and renew for 2 years
assert scenario == [
('AT_STARTUP', 'VERIFY?', 'run'),
('VERIFY?', 'RESTORE!', 'verify-ok'),
('RESTORE!', 'REFRESH', 'response'),
('REFRESH', 'RENEW', 'refresh-ok'),
('RENEW', 'RENEW', 'refresh-ok'),
]
assert len(outputs) == 7
assert tester_domain.epp_id is not None
def test_domain_pending_delete_status_not_set():
if os.environ.get('E2E', '0') != '1':
return pytest.skip('skip E2E') # @UndefinedVariable
# first need to read existing domain from back-end and create it in local DB
testsupport.prepare_tester_registrant(epp_id='tester065480yp60',
create_new=True)
test_domain_name = 'test-pending-delete-status-not-set.%s' % settings.ZENAIDA_SUPPORTED_ZONES[
0]
zmaster.domain_synchronize_from_backend(
domain_name=test_domain_name,
refresh_contacts=True,
change_owner_allowed=False,
soft_delete=False,
)
tester_domain = zdomains.domain_find(domain_name=test_domain_name)
assert tester_domain.epp_id is not None
# now try to restore it
scenario = []
dr = domain_resurrector.DomainResurrector(
log_events=True,
log_transitions=True,
raise_errors=True,
)
dr.add_state_changed_callback(
cb=lambda oldstate, newstate, event, *args, **kwargs: scenario.append((
oldstate,
newstate,
event,
)),
)
dr.event('run', domain_object=tester_domain)
outputs = list(dr.outputs)
del dr
# this domain is not possible to restore because status is not pending delete
assert scenario == [
('AT_STARTUP', 'VERIFY?', 'run'),
('VERIFY?', 'RESTORE!', 'verify-ok'),
('RESTORE!', 'FAILED', 'error'),
]
assert tester_domain.epp_id is not None
assert len(outputs) == 5
assert isinstance(outputs[-1], Exception)
def do_domain_contacts_changed(domain):
logger.info('domain %s contacts changed', domain)
# step 1: read info from back-end and make changes in local DB
try:
outputs1 = zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=True,
rewrite_contacts=False,
change_owner_allowed=True,
create_new_owner_allowed=True,
)
except rpc_error.EPPError:
logger.exception('failed to synchronize domain from back-end: %s' %
domain)
return False
logger.info('outputs1: %r', outputs1)
# step 2: write changes to back-end
try:
outputs2 = zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=True,
rewrite_contacts=True,
change_owner_allowed=False,
)
except rpc_error.EPPError:
logger.exception('failed to re-write domain info on back-end: %s' %
domain)
return False
logger.info('outputs2: %r', outputs2)
# step 3: read again latest info from back-end and make sure all contacts are refreshed
try:
outputs3 = zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=True,
rewrite_contacts=False,
change_owner_allowed=False,
)
except rpc_error.EPPError:
logger.exception(
'failed to synchronize domain contacts from back-end: %s' % domain)
return False
logger.info('outputs3: %r', outputs3)
return True
def sync_to_be_deleted_domains_from_backend():
"""
Syncs domains with "to_be_deleted" status from the backend.
"""
domains = zdomains.list_domains_by_status(status='to_be_deleted')
for domain in domains:
zmaster.domain_synchronize_from_backend(
domain_name=domain.name,
refresh_contacts=True,
rewrite_contacts=False,
change_owner_allowed=False,
create_new_owner_allowed=False,
soft_delete=True,
raise_errors=True,
log_events=True,
log_transitions=True,
)
domain.refresh_from_db()
logger.info(
f'{domain.name} status after backend sync: {domain.status}')
def execute_domain_renew(order_item, target_domain):
"""
Execute domain renew order fulfillment and update order item.
"""
if not zmaster.domain_check_create_update_renew(
domain_object=target_domain,
sync_contacts=False,
sync_nameservers=True,
renew_years=2,
log_events=True,
log_transitions=True,
raise_errors=False,
):
update_order_item(order_item,
new_status='failed',
charge_user=False,
save=True)
return False
ret = update_order_item(order_item,
new_status='processed',
charge_user=True,
save=True)
zmaster.domain_synchronize_from_backend(
domain_name=order_item.name,
refresh_contacts=False,
rewrite_contacts=False,
change_owner_allowed=False,
create_new_owner_allowed=False,
soft_delete=False,
domain_transferred_away=False,
raise_errors=False,
log_events=True,
log_transitions=True,
)
return ret
def do_domain_nameservers_changed(domain):
logger.info('domain %s nameservers changed', domain)
try:
outputs = zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=False,
change_owner_allowed=False,
)
except rpc_error.EPPError:
logger.exception('failed to synchronize domain from back-end: %s' %
domain)
return False
logger.info('outputs: %r', outputs)
return True
def do_domain_change_unknown(domain):
logger.info('domain %s change is unknown, doing hard-synchronize', domain)
try:
outputs = zmaster.domain_synchronize_from_backend(
domain_name=domain,
refresh_contacts=True,
rewrite_contacts=True,
change_owner_allowed=True,
create_new_owner_allowed=True,
)
except rpc_error.EPPError:
logger.exception('failed to synchronize domain from back-end: %s' %
domain)
return False
logger.info('outputs: %r', outputs)
return True
def execute_domain_transfer(order_item):
"""
Execute domain transfer take-over order fulfillment and update order item, status will be "pending".
"""
if hasattr(order_item, 'details') and order_item.details.get('internal'):
domain = zdomains.domain_find(order_item.name)
if not domain:
logger.info(
'domain name %r was not found in local DB, sync from back-end',
order_item.name)
zmaster.domain_synchronize_from_backend(
domain_name=order_item.name,
refresh_contacts=True,
rewrite_contacts=False,
change_owner_allowed=True,
create_new_owner_allowed=True,
soft_delete=False,
domain_transferred_away=False,
raise_errors=True,
log_events=True,
log_transitions=True,
)
domain = zdomains.domain_find(order_item.name)
if not domain:
logger.critical(
'failed to synchronize domain %r, not possible to finish internal transfer',
order_item.name)
return False
if domain.auth_key and domain.auth_key != order_item.details.get(
'transfer_code'):
logger.critical(
'failed to finish internal domain transfer of %r because of invalid transfer code',
domain)
return False
# Change the owner of the domain with removing his/her contact and updating the new contact
oldest_registrant = zcontacts.get_oldest_registrant(
order_item.order.owner)
zdomains.domain_change_registrant(domain, oldest_registrant, True)
zdomains.domain_detach_contact(domain, 'admin')
zdomains.domain_detach_contact(domain, 'billing')
zdomains.domain_detach_contact(domain, 'tech')
zdomains.domain_join_contact(domain, 'admin',
order_item.order.owner.contacts.first())
domain.refresh_from_db()
# Override info on back-end
zmaster.domain_synchronize_from_backend(
domain_name=domain.name,
refresh_contacts=False,
rewrite_contacts=True,
change_owner_allowed=False,
expected_owner=order_item.order.owner,
soft_delete=True,
raise_errors=True,
log_events=True,
log_transitions=True,
)
domain.refresh_from_db()
# Override registrant on back-end
zmaster.domain_synchronize_contacts(
domain,
merge_duplicated_contacts=True,
rewrite_registrant=True,
new_registrant=None,
raise_errors=True,
log_events=True,
log_transitions=True,
)
domain.refresh_from_db()
try:
zmaster.domain_set_auth_info(domain)
except Exception as e:
logger.exception(
'failed changing auth code for %r after internal transfer' %
domain)
update_order_item(order_item,
new_status='failed',
charge_user=False,
save=True,
details={
'error': str(e),
})
return False
domain.refresh_from_db()
# Auth key shouldn't be used anymore as transfer is done.
domain.auth_key = ''
domain.save()
# In the end, order is done so, update order item as processed.
update_order_item(order_item,
new_status='processed',
charge_user=True,
save=True)
return True
if not zmaster.domain_transfer_request(
domain=order_item.name,
auth_info=order_item.details.get('transfer_code'),
):
update_order_item(order_item,
new_status='failed',
charge_user=False,
save=True)
return False
return update_order_item(order_item,
new_status='pending',
charge_user=False,
save=True)
