def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.device = G(GCMDevice)
self.device.refresh_from_db()
self.url = reverse('v1:gcm-devices-detail', args=(self.instance.name, self.device.registration_id))
self.config = GCMConfig.objects.create(development_api_key='123qwe')
def test_storage_limit_causes_a_block(self):
set_current_instance(self.instance)
klass = G(Klass,
schema=[{
'name': 'file',
'type': 'file'
}],
name='test',
description='test')
url = reverse('v1:dataobject-list',
args=(self.instance.name, klass.name))
with tempfile.NamedTemporaryFile() as tmp_file:
tmp_file.write(b'*' * 1000)
tmp_file.seek(0)
response = self.client.post(url, {'file': tmp_file},
format='multipart')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
with tempfile.NamedTemporaryFile() as tmp_file:
tmp_file.write(b'*' * 1000)
tmp_file.seek(0)
response = self.client.post(url, {'file': tmp_file},
format='multipart')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def _migrate_tenants(self, tenants, apps):
for tenant in tenants:
db = get_instance_db(tenant)
connection = connections[db]
set_current_instance(tenant)
self._notice("=== Running migrate for schema: %s" %
tenant.schema_name)
signals.pre_tenant_migrate.send(sender=tenant,
tenant=tenant,
verbosity=self.verbosity,
using=connection.alias)
schema_created = self._migrate_schema(connection, tenant)
with ignore_signal(post_migrate):
self.run_migrations(connection,
apps,
schema_created=schema_created,
skip_checks=True)
signals.post_tenant_migrate.send(
sender=tenant,
tenant=tenant,
verbosity=self.verbosity,
using=connection.alias,
created=schema_created,
partial=False,
)
def setUp(self):
super().setUp()
set_current_instance(self.instance)
schema = [
{
'name': 'name',
'type': 'string'
},
{
'name': 'ref',
'type': 'reference',
'target': 'self'
},
{
'name': 'user',
'type': 'reference',
'target': 'user'
},
]
self.klass = G(Klass, schema=schema, name='test', description='test')
DataObject.load_klass(self.klass)
self.object = G(DataObject, _klass=self.klass, name='a')
self.user = G(User)
DataObject.load_klass(self.klass)
self.object_2 = G(DataObject,
_klass=self.klass,
name='b',
user=self.user.pk,
ref=self.object.pk)
self.hla = G(DataObjectHighLevelApi, klass=self.klass)
self.endpoint_url = reverse('v2:hla-objects-endpoint',
args=[self.instance.name, self.hla.name])
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.socket = G(Socket, name='name', status=Socket.STATUSES.OK)
self.schedule = G(CodeBoxSchedule, socket=self.socket)
self.url = reverse('v1:codebox-schedule-detail', args=(self.instance.name, self.schedule.id,))
def setUp(self):
super().setUp()
instance_data = {
'name': 'anothertestinstance', 'description': 'another test desc', 'owner': self.admin
}
self.another_instance = G(Instance, **instance_data)
self.admin.add_to_instance(self.another_instance)
set_current_instance(self.instance)
self.hosting = G(Hosting, name='test_name_one', description='test_description')
set_current_instance(self.another_instance)
self.another_hosting = G(Hosting, name='test_name_two', description='test_description')
self.url = reverse('v1.1:hosting-list', args=(self.instance.name,))
self.detail_url = reverse('v1.1:hosting-detail', args=(self.instance.name, self.hosting.id))
self.another_url = reverse('v1.1:hosting-list', args=(self.another_instance.name,))
self.another_detail_url = reverse('v1.1:hosting-detail', args=(self.another_instance.name,
self.another_hosting.id))
self.hosting_data = {
'name': 'some_name',
'description': 'some_description',
'domains': ['test.test.io']
}
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.webhook = Webhook.objects.create(name='webhook', codebox=G(CodeBox))
self.url = reverse('v1:webhook-detail', args=(self.instance.name, self.webhook.name,))
def test_user_is_created_only_once(self):
self.client.post(self.url, self.post_data)
set_current_instance(self.instance)
self.assertEquals(User.objects.count(), 1)
self.client.post(self.url, self.post_data)
self.assertEquals(User.objects.count(), 1)
def instance_context(instance):
previous_instance = get_current_instance()
try:
set_current_instance(instance)
yield
finally:
set_current_instance(previous_instance)
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.config = G(GCMConfig, development_api_key='test')
self.message = G(GCMMessage)
self.url = reverse('v1:gcm-messages-detail',
args=(self.instance.name, self.message.pk))
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.klass = G(Klass,
schema=[{
'name': 'name',
'type': 'string'
}, {
'name': 'geo',
'type': 'geopoint',
'filter_index': True
}],
name='klas')
DataObject.load_klass(self.klass)
for name, geo_data in (
('Warsaw', Point(21.0122, 52.2297)),
('Krakow', Point(19.9450, 50.0647)), # 252km distance
('Lodz', Point(19.4560, 51.7592)), # 119km
('Otwock', Point(21.2616, 52.1053)), # 21km
('empty', None)):
DataObject.objects.create(_klass=self.klass,
name=name,
geo=geo_data)
self.url = reverse('v1:dataobject-list',
args=(self.instance.name, self.klass.name))
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.config = G(APNSConfig)
self.message = G(APNSMessage)
self.url = reverse('v1:apns-messages-detail',
args=(self.instance.name, self.message.pk))
def test_if_codebox_run_increments_instance_counter(self):
self.assertIsNone(redis.get(self.codebox_limit_key))
CodeBoxTask.delay(**self.run_kwargs)
set_current_instance(self.instance)
self.assertEqual(redis.get(self.codebox_limit_key), b'1')
def get_incentive(self, instance, incentive_pk):
set_current_instance(instance)
try:
incentive = Cached(self.incentive_class, kwargs={'pk': incentive_pk}).get()
except self.incentive_class.DoesNotExist:
self.get_logger().warning(
"%s[pk=%s] for %s cannot be run, because script was not found.",
self.incentive_class.__name__, incentive_pk, instance)
return None
if hasattr(incentive, 'codebox_id'):
try:
incentive.codebox = Cached(CodeBox, kwargs={'pk': incentive.codebox_id}).get()
except CodeBox.DoesNotExist:
self.get_logger().warning(
"%s[pk=%s] for %s cannot be run, because script was not found.",
self.incentive_class.__name__, incentive.pk, instance)
return None
socket = None
if incentive.socket_id:
try:
socket = Cached(Socket, kwargs={'pk': incentive.socket_id}).get()
except Socket.DoesNotExist:
pass
incentive.socket = socket
return incentive
def run(self, trace_spec, result_info):
instance = self._get_instance(trace_spec)
if not instance:
return
set_current_instance(instance)
trace_class = self._get_trace_class(trace_spec)
trace = self._get_trace(trace_spec, trace_class)
for k, v in result_info.items():
setattr(trace, k, v)
if not trace._saved:
# If we're dealing with unsaved object, we need the list key as well so pass kwargs for it
trace.save(**self._get_trace_context(trace_spec))
else:
trace.save(update_fields=result_info.keys())
if trace_spec['type'] == 'schedule':
ScheduleNextTask.delay(instance_pk=trace_spec['instance_id'],
schedule_id=trace_spec['obj_id'])
if 'socket' in trace_spec:
self.publish_log(instance, trace, trace_spec)
codebox_finished.send(sender=trace_class,
instance=instance,
object_id=trace_spec['obj_id'],
trace=trace)
def test_user_is_created(self):
set_current_instance(self.instance)
self.assertFalse(User.objects.exists())
self.client.post(self.url, self.post_data)
set_current_instance(self.instance)
self.assertTrue(User.objects.exists())
def run(self, instance_pks):
for instance_pk in instance_pks:
instance = _get_instance(instance_pk)
if instance is None:
continue
if not OwnerInGoodStanding.is_admin_in_good_standing(
instance.owner_id):
continue
set_current_instance(instance)
schedules = CodeBoxSchedule.objects.get_for_process()
for schedule in schedules:
key = PERIODIC_SCHEDULE_TEMPLATE.format(
instance_pk=instance.pk,
schedule_pk=schedule.pk,
scheduled_at=schedule.scheduled_next.isoformat())
can_run = redis.set(name=key,
value=1,
nx=True,
ex=SCHEDULE_TRACE_TIMEOUT)
if not can_run:
time_in_queue = timezone.now() - schedule.scheduled_next
if time_in_queue > timedelta(minutes=2):
self.get_logger().warning(
"%s in %s cannot be run yet, because it was already scheduled for %s, time in queue: %s.",
schedule, instance,
schedule.scheduled_next.isoformat(), time_in_queue)
else:
ScheduleTask.delay(schedule.id, instance_pk)
if schedules:
admin = Cached(Admin, kwargs={'id': instance.owner_id}).get()
admin.update_last_access()
def publish_log(self, instance, trace, trace_spec):
serializer_class = self._get_serializer_class(trace_spec)
view_kwargs = self._get_trace_context(trace_spec)
view_kwargs['instance'] = instance
trace.executed_at = parse_datetime(trace.executed_at)
payload = serializer_class(trace, excluded_fields=('links', )).data
trace_self_link = reverse('{}:{}'.format(
self.api_version, serializer_class.hyperlinks[0][1]),
args=(instance.name, trace_spec['obj_name']
or trace_spec['obj_id'], trace.pk))
payload['links'] = {'self': trace_self_link}
socket = trace_spec['socket']
room = 'socket:{}'.format(socket)
metadata = {'type': 'trace', 'socket': socket}
if trace_spec['type'] == 'socket_endpoint':
metadata['source'] = 'endpoint'
metadata['endpoint'] = trace_spec['obj_name']
elif trace_spec['type'] in ('trigger', 'schedule'):
metadata['source'] = 'event_handler'
metadata['event_handler'] = trace_spec['event_handler']
set_current_instance(instance)
channel = Channel.get_eventlog()
channel.create_change(room=room,
author={},
metadata=metadata,
payload=payload,
action=Change.ACTIONS.CUSTOM)
def initialize_request(self, request, *args, **kwargs):
instance = getattr(request, 'instance', kwargs.get('instance', None))
if not isinstance(instance, Instance):
value = instance.lower()
instance = None
if INSTANCE_NAME_REGEX.match(value):
try:
instance = Cached(Instance, kwargs=dict(name=value)).get()
except Instance.DoesNotExist:
pass
if instance is not None:
try:
self.validate_instance(instance)
if getattr(request, 'instance',
None) is None and request.META.get(
'HTTP_HOST_TYPE') != 'hosting':
admin = Cached(Admin, kwargs={
'id': instance.owner_id
}).get()
admin.update_last_access()
self.kwargs['instance'] = instance
set_current_instance(instance)
except SyncanoException as ex:
request.error = ex
instance = None
request.instance = instance
return super().initialize_request(request, *args, **kwargs)
def run(self, model_class_name, object_pk, instance_pk=None, **kwargs):
logger = self.get_logger()
try:
model_class = apps.get_model(model_class_name)
except (LookupError, ValueError):
# do not retry
raise
if instance_pk is not None:
try:
instance = Cached(Instance, kwargs=dict(pk=instance_pk)).get()
set_current_instance(instance)
except Instance.DoesNotExist:
logger.warning(
'Error occurred during deletion of %s[pk=%s] in Instance[pk=%s]. '
'Instance no longer exists.', model_class_name, object_pk,
instance_pk)
return
logger.info('Deleting %s[pk=%s] in %s.', model_class_name,
object_pk, instance)
else:
logger.info('Deleting %s[pk=%s] in public schema.',
model_class_name, object_pk)
try:
db = router.db_for_write(model_class)
with transaction.atomic(db):
model_class.all_objects.filter(pk=object_pk).delete()
except Exception as exc:
raise self.retry(exc=exc)
def test_codebox_task_handles_dead_codebox(self):
self.schedule.schedule_now()
self.schedule.codebox.soft_delete()
ScheduleTask.delay(self.schedule.pk, self.instance.pk)
set_current_instance(self.instance)
trace_list = ScheduleTrace.list(schedule=self.schedule)
self.assertEqual(len(trace_list), 0)
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.config = G(APNSConfig)
self.url = reverse('v1:apns-messages-list',
args=(self.instance.name, ))
def setUp(self):
self.instance = G(Instance, name='testtest')
self.admin = G(Admin, is_active=True)
self.admin.add_to_instance(self.instance)
self.apikey = self.admin.key
self.client.defaults['HTTP_X_API_KEY'] = self.apikey
source = 'print META'
runtime_name = LATEST_PYTHON_RUNTIME
set_current_instance(self.instance)
self.codebox = CodeBox.objects.create(label='test',
source=source,
runtime_name=runtime_name)
self.klass = G(Klass,
name='dog',
schema=[{
'name': 'name',
'type': 'string'
}])
DataObject._meta.get_field('_data').reload_schema(None)
self.signal = 'post_delete'
klass_pk = self.klass.pk
self.event_characteristics = (self.signal, klass_pk)
self.trigger = Trigger.objects.create(signal=self.signal,
codebox=self.codebox,
klass=self.klass)
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.socket = G(Socket, name='name', status=Socket.STATUSES.OK)
self.hosting = G(Hosting, socket=self.socket)
self.edit_url = reverse('v1.1:hosting-detail', args=(self.instance.name, self.hosting.id,))
self.set_default_url = reverse('v1.1:hosting-set-default', args=(self.instance.name, self.hosting.id,))
def test_running_codebox_with_crontab_schedule(self):
self.schedule.interval_sec = None
self.schedule.crontab = "2 * * * *"
self.schedule.schedule_now()
ScheduleTask.delay(self.schedule.pk, self.instance.pk)
set_current_instance(self.instance)
trace_list = ScheduleTrace.list(schedule=self.schedule)
self.assertEqual(len(trace_list), 1)
def test_schedule_with_dead_codebox_will_not_be_run(
self, codebox_task_mock):
self.schedule.schedule_now()
codebox = self.schedule.codebox
codebox.soft_delete()
SchedulerDispatcher.delay()
set_current_instance(self.instance)
self.assertFalse(codebox_task_mock.called)
def test_running_task(self):
codebox = self.create_codebox()
CodeBoxTask.delay(incentive_pk=codebox.id,
instance_pk=self.instance.pk)
set_current_instance(self.instance)
self.assertEqual(
CodeBoxTrace.list(codebox=codebox)[0].result['stdout'], "hello")
def test_schedule_tasks_integration(self, process_mock):
self.schedule_tasks(self.instance.pk, Trigger.objects.all(),
{'name': 'Brunhilda'})
set_current_instance(self.instance)
traces_list = TriggerTrace.list(trigger=self.trigger)
self.assertEqual(len(traces_list), 1)
last_trace = traces_list[0]
self.assertEqual(last_trace.status, 'success')
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.socket = G(Socket, name='name', status=Socket.STATUSES.OK)
self.script = G(CodeBox, socket=self.socket)
self.edit_url = reverse('v1:codebox-detail', args=(self.instance.name, self.script.id,))
self.run_url = reverse('v1:codebox-run', args=(self.instance.name, self.script.id,))
def setUp(self):
super().setUp()
set_current_instance(self.instance)
self.socket = G(Socket, name='name', status=Socket.STATUSES.OK)
self.webhook = G(Webhook, socket=self.socket)
self.edit_url = reverse('v1:webhook-detail', args=(self.instance.name, self.webhook.name,))
self.run_url = reverse('v1:webhook-run', args=(self.instance.name, self.webhook.name,))
