def test_glue_basic(self):
glue = Glue()
glue.parse(self.get_file('files/Gain.h'))
self.assertEqual(1, len(glue.blocks))
block = list(glue.blocks.values())[0]
self.assertEqual('Gain', block.name)
self.assertEqual('SomeProject', block.namespace)
self.assertEqual('signal', block.family)
self.assertTrue('description' in block.meta)
self.assertEqual('Some gain', block.meta['description'])
self.assertTrue('small' in block.meta)
self.assertEqual(True, block.meta['small'])
self.assertEqual(3, len(block.fields))
self.assertTrue('gain' in block.fields)
self.assertTrue('input' in block.fields)
self.assertTrue('output' in block.fields)
gain = block.fields['gain']
self.assertEqual(['editable', 'input'], gain.attrs)
self.assertEqual('1.0', gain.default)
self.assertEqual('float', gain.type)
self.assertFalse(gain.multiple)
input = block.fields['input']
self.assertEqual(['input'], input.attrs)
self.assertFalse(input.multiple)
self.assertEqual('float', input.type)
output = block.fields['output']
self.assertEqual(['output'], output.attrs)
self.assertFalse(output.multiple)
self.assertEqual('getOutput()', output.get())
self.assertEqual('float', output.type)
def test_glue_tick_method(self):
glue = Glue()
glue.parse(self.get_file('files/Add.h'))
self.assertEqual(1, len(glue.blocks))
block = list(glue.blocks.values())[0]
self.assertEqual(2, len(block.fields))
events = block.get_event_methods('tick')
self.assertEqual(['compute'], events)
self.assertTrue('terms' in block.fields)
terms = block.fields['terms']
self.assertTrue(terms.multiple)
self.assertTrue('extensible' in terms.meta)
self.assertTrue('resize' in terms.get_prepare('0'))
def test_glue_generation_basic(self):
glue = Glue()
glue.parse(self.get_file('files/Gain.h'))
glue.parse(self.get_file('files/Gains.h'))
glue.parse(self.get_file('files/Add.h'))
self.generate(glue)
self.assertTrue(os.path.isdir(self.get_output('glue')))
self.check_cpp_file('glue/glue.cpp')
self.check_cpp_file('glue/convert.h')
self.check_cpp_file('glue/deserialize.h')
self.check_cpp_file('glue/GlueTypes.h')
self.check_cpp_file('glue/GlueGain.cpp')
self.check_cpp_file('glue/GlueGain.h')
self.check_cpp_file('glue/GlueGains.cpp')
self.check_cpp_file('glue/GlueGains.h')
self.check_cpp_file('glue/GlueAdd.h')
self.check_cpp_file('glue/GlueAdd.cpp')
self.assertTrue(os.path.isdir(self.get_output('web')))
self.assertTrue(os.path.isdir(self.get_output('web/blocks.js')))
self.assertTrue(os.path.isdir(self.get_output('web/js')))
self.assertTrue(os.path.isfile(self.get_output('web/js/glue_data.js')))
self.assertTrue(os.path.isfile(self.get_output('web/index.html')))
def test_glue_errors(self):
glue = Glue()
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadAnnotation1.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadAnnotation2.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadAnnotation3.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadField1.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadField2.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadField3.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadField4.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadField5.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadField6.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadEvent1.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadEvent2.h')))
self.assertRaises(GlueException, lambda: glue.parse(self.get_file('files/BadEvent3.h')))
def __get_shader_data(self, shaders, file_name):
result = ""
i = 0
for shader in shaders:
r = self.__get_shader(file_name, shader)
if not i:
result = r
else:
result = Glue.glue(result, r, i)
i += 1
return result
def test_glue_multiple(self):
glue = Glue()
glue.parse(self.get_file('files/Gains.h'))
self.assertEqual(1, len(glue.blocks))
block = list(glue.blocks.values())[0]
self.assertEqual('Gains', block.name)
self.assertEqual(3, len(block.fields))
self.assertTrue('gains' in block.fields)
self.assertTrue('input' in block.fields)
self.assertTrue('output' in block.fields)
gains = block.fields['gains']
self.assertFalse(gains.multiple)
self.assertEqual('std::vector<float>', gains.type)
self.assertEqual('[1]', gains.default)
self.assertEqual(['editable'], gains.attrs)
self.assertTrue(gains.is_editable())
self.assertFalse(gains.is_output())
input = block.fields['input']
self.assertTrue(input.multiple)
self.assertTrue('dimension' in input.meta)
self.assertEqual('gains', input.meta['dimension'])
self.assertEqual(['input'], input.attrs)
self.assertEqual('std::vector<float>', input.type)
self.assertEqual('float', input.accessor_type())
self.assertTrue(input.is_input())
self.assertFalse(input.is_editable())
output = block.fields['output']
self.assertTrue(output.multiple)
self.assertEqual('float', output.type)
self.assertEqual('float', output.accessor_type())
self.assertEqual(['output'], output.attrs)
self.assertFalse(output.is_input())
# -*- coding: utf-8 -*- import os, sys, time import numpy as np sys.path.append(os.path.split(os.getcwd())[0]) from glue import Glue glue = Glue() glue.start()
def start_crawler(event, context):
glue = Glue()
crawler_id_1 = glue.get_crawler_name(event)
thread_pool = ThreadPool()
thread_pool.add(glue.start_crawler, crawler_id_1)
thread_pool.wait()
def handler(event, context):
print "Start Glue"
stack_id = event[c.ENV_STACK_ID]
resources = util.get_stack_resources(stack_id)
request_type = event['RequestType']
db_name = athena.get_database_name(stack_id, False)
glue = Glue()
for resource in resources:
if resource.logical_id == c.RES_SERVICE_ROLE:
role_name = resource.physical_id
if resource.logical_id == c.RES_S3_STORAGE:
storage_physical_id = resource.physical_id
if role_name is None:
raise errors.ClientError(
"The logical resource '{}' was not found. Is the resource in the cloud formation stack?"
.format(c.RES_SERVICE_ROLE))
if storage_physical_id is None:
raise errors.ClientError(
"The logical resource '{}' was not found. Is the resource in the cloud formation stack?"
.format(c.RES_S3_STORAGE))
crawler_id_1 = glue.get_crawler_name(stack_id)
srcs = [{
'Path':
"{}/{}{}".format(storage_physical_id, "table=",
DEFAULT_EVENTS.CLIENTINITCOMPLETE),
'Exclusions': []
}, {
'Path':
"{}/{}{}".format(storage_physical_id, "table=",
DEFAULT_EVENTS.SESSIONSTART),
'Exclusions': []
}]
print request_type, db_name, crawler_id_1, "role: ", role_name, "s3: ", storage_physical_id
if request_type.lower() == 'delete':
if glue.get_crawler(crawler_id_1) is not None:
glue.stop_crawler(crawler_id_1)
glue.delete_crawler(crawler_id_1)
if glue.database_exists(db_name):
glue.delete_database(db_name)
elif request_type.lower() == 'create':
if not glue.database_exists(db_name):
glue.create_database(db_name)
if glue.get_crawler(crawler_id_1) is None:
glue.create_crawler(crawler_id_1,
role_name,
db_name,
athena.get_table_prefix(stack_id),
srcs=srcs)
else:
if glue.get_crawler(crawler_id_1) is None:
glue.create_crawler(crawler_id_1,
role_name,
db_name,
athena.get_table_prefix(stack_id),
srcs=srcs)
else:
glue.stop_crawler(crawler_id_1)
glue.update_crawler(crawler_id_1, role_name, db_name,
athena.get_table_prefix(stack_id))
return custom_resource_response.success_response({}, "*")
def get_crawler_status(request, name):
glue_crawler = Glue()
response = glue_crawler.get_crawler(name.replace('-', '_'))
return custom_resource_response.success_response(
{"State": response['Crawler']['State']}, "*")
def events(request):
glue = Glue()
return glue.get_events()
def test_glue_dummy(self):
glue = Glue()
glue.parse(self.get_file('files/Dummy.h'))
self.assertEqual(1, len(glue.blocks))
from glue import Glue, GlueException
try:
# The Glue generator, generates:
#
# - glue.cpp: glue functions
# glue_getter, glue_setter, glue_link, glue_name_to_index,
# glue_instanciate, glue_is_convertible
# - deserialize.h, convert.h: headers for methods that converts and
# deserializes compatible types
# - GlueTypes.h: all type classes (Node_get_* and Node_set_*), with
# their methods glue_import, glue_output_type, glue_get_* and glue_set_*
# - Glue*.cpp: all the special classes inheriting
# - blocks.json: blocks meta descriptions
glue = Glue()
# Getting output directory, creating it if necessary
glue_dir = sys.argv[1]
# Getting output directory, creating it if necessary
output_dir = sys.argv[2]
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
# Getting output directory for web files
web_dir = sys.argv[3]
if os.path.isdir(web_dir):
shutil.rmtree(web_dir)
# Type compatibilities
channel = socket.Channel('test')
channel.on_message(on_message_test)
def on_message(socket, data, channel):
"""
onMessage for main channel
"""
print('Received data:', data)
socket.sendToMain('Hello world!')
def on_message_test(chan, data):
print('Channel: %s' % chan.channel, 'Data: %s' % data)
chan.send(data)
if __name__ == '__main__':
import sys
from twisted.python import log
from twisted.internet import reactor
log.startLogging(sys.stdout)
glue = Glue(u"ws://127.0.0.1:8081/glue/ws")
glue.factory.protocol = CustomGlueProtocol
reactor.run()
import os
import sys
import db
from glue import Glue, unquote_gluestring
from config import Config
import re
if len(sys.argv) < 2:
print('No config file provided')
exit(1)
cfg = Config(sys.argv[1])
glue = Glue(staging=cfg.staging)
glue.login(cfg.username, cfg.password)
glue.connect_to_host(cfg.company_id)
company = glue.get_company(cfg.company_id)
project = glue.get_project(cfg.project_name)
if cfg.dry:
print('Info: dry run enabled')
# get project notification settings
project_settings = glue.get_project_user_notification_settings(
project.project_id)
notification_settings = ';'.join([
x for x in project_settings['notification_settings']
if project_settings['notification_settings'][x] == '1'
])
