def main():
#handle argument
parser = argparse.ArgumentParser(description='fetch and check free proxies')
parser.add_argument('-v', '--verbose', action='store_true')
parser.add_argument('-l', '--load', action='store_true', help='load hub.plk file')
args = parser.parse_args(sys.argv[1:])
if args.verbose:
set_console_log_level(logging.DEBUG)
if args.load:
with (open("hub.pkl", "rb")) as f:
_hub = pickle.load(f)
hub = Hub(_hub)
else:
hub = Hub()
log.info('Start')
loop = asyncio.get_event_loop()
queue = asyncio.Queue()
factory = Factory(loop, queue, fetchers, hub)
tasks = factory.get_tasks()
tasks.append(asyncio.ensure_future(Server(hub).run()))
tasks = asyncio.gather(*tasks, loop=loop)
try:
loop.run_until_complete(tasks)
except KeyboardInterrupt:
with open('hub.pkl', 'wb') as f:
pickle.dump(hub.copy(), f, pickle.HIGHEST_PROTOCOL)
finally:
loop.close()
def setup_value(line_name, alist, conn=False):
"""
Set value in instance type for all stations and all transfer points.
"""
from station import Station
from hub import Hub
ls_instance = []
for item in alist:
ls_inform = item.split(':')
flag_set = False
if conn and len(ls_inform) == 4:
new_instance = Hub()
new_instance.conn = ls_inform[-1]
flag_set = True
if not conn:
new_instance = Station()
flag_set = True
if flag_set:
new_instance.name = ls_inform[1]
new_instance.line = line_name
new_instance.id = ls_inform[0]
if not conn or conn and len(ls_inform) == 4:
ls_instance.append(new_instance)
return ls_instance
def __init__(self, nLines=64, associativity=8, pageSize=0x1000, tlb=None, cache=None, hub=None):
"""Simple associative cache.
Parameters
----------
size (int):
Cache size in bytes. (Default 0x8000 (32 kB))
associtivilty (int):
Number of ways for an associative cache, -1 for fully associative.
cacheLine (int):
Number of bytes per cache line, determiines the number of offset bits.
child (Cache):
The next level of cache, must be a hub for etlb, default is None, which means default Hub.
"""
self.nLines = nLines
self.associativity = associativity
self.hub = hub
self.cache = cache
self.tlb = tlb
self.pageSize = pageSize
if self.associativity == -1:
self.associativity = self.nLines
if self.hub is None:
self.hub = Hub(associativity=self.associativity, pageSize=self.pageSize)
if self.cache is None:
self.cache = Cache(size=0x8000, associativity=16)
self.cache.accessEnergy = 0.0111033
self.cache.accessTime = 4
self.cache.tagTime = 1
self.cache.tagEnergy = 0.000539962
self.hub.eTLB = self
self.cacheLine = self.cache.cacheLine
self.nSets = self.nLines // self.associativity
self.offsetBits = int(math.ceil(math.log2(self.cacheLine)))
self.wayBits = int(math.ceil(math.log2(self.associativity)))
self.pageBits = int(math.ceil(math.log2(self.pageSize))) - self.offsetBits
self.setBits = int(math.ceil(math.log2(self.nSets)))
self.tagBits = 48 - self.setBits - self.pageBits - self.offsetBits
if self.tlb is None:
self.tlb = TLB(512, self.tagBits + self.setBits)
self.freeList = [list(range(self.associativity)) for i in range(self.nSets)]
self.counter = 0
self.entries = [[ETLBEntry(self.pageSize, self.cacheLine) for i in range(self.associativity)] for j in range(self.nSets)]
self.hit = [0,0,0,0] #DRAM,L1I,L1D,L2 Note: L1 is actually a unified cache at present, for forward compatability if separate caches are ever implemented
self.miss = 0
self.cycles = 0
self.energy = 0.
def main():
# print(os.path.abspath(os.path.dirname(__file__)))
# print(schema_etl)
order_load = ["hub", "lnk", "sat", 'raw', 'hashed']
for type_obj in order_load:
for etl_val_obj in schema_etl[type_obj]:
hub = Hub()
next_sql = hub.generate_general_fill(etl_val_obj)
print(next_sql)
def test_post_success(self):
r1 = self.delete_server_hub_map()
self.assertEqual(r1.status_code, server.OK)
r2 = self.post_server_hub_map()
hub = Hub(restaurant_id=self.restaurant_id)
self.assertEqual(r2.status_code, server.CREATED)
self.assertTrue(hub.get_attendant_id(self.hub_id), self.attendant_id)
def restaurant_endpoint(table_id=''):
"""
Handles creation and queries for restaurant data.
:param table_id: hub device ID.
:return: JSON or CSV response body and status code.
"""
if request.method == 'GET':
hub_id = request.args.get('table_id', table_id)
hub = Hub('')
hub.get_restaurant_id(hub_id=hub_id)
# if Mime Type is CSV, respond with simple restaurant ID string.
if request.content_type == 'text/csv':
print hub.restaurant_id
if hub.restaurant_id:
return hub.restaurant_id, OK
else:
return 'error', BAD_REQUEST
# Otherwise, respond in JSON format.
else:
if hub.restaurant_id:
return jsonify({
'table_id': hub_id,
'restaurant_id': hub.restaurant_id
}), OK
else:
return jsonify({
'table_id':
hub_id,
'error':
'Specified table ID is not affiliated with a restaurant.'
}), BAD_REQUEST
elif request.method == 'POST':
request_body = flask.request.get_json()
# Restaurant name must be supplied in request body.
if 'name' in request_body:
restaurant_name = request_body['name']
else:
request_body.update({'error': 'Restaurant name not specified.'})
return jsonify(request_body), BAD_REQUEST
# Create new restaurant, and return result to user.
restaurant = Restaurant(restaurant_id='')
restaurant_info = restaurant.create(name=restaurant_name)
if 'error' in restaurant_info:
return jsonify(restaurant_info), SERVER_ERROR
else:
return jsonify(restaurant_info), OK
def __init__(self, _engine):
super(Scene, self).__init__()
self._ais = []
self._engine = _engine
self._resx, self._resy = _engine.getResolution()
self.surface = pygame.Surface((self._resx, self._resy))
drawText(self.surface, "Wczytywanie mapy...", 48, (255, 255, 255),
(self._resx / 2, self._resy / 2))
self._map = Map(_engine)
self._hub = Hub(_engine, self._map)
self._cursor = Cursor(_engine, self._map)
self._ais.append(AI(_engine, self._map, _engine.players[0], 0))
self._ais.append(AI(_engine, self._map, _engine.players[1], 1))
def init(self, hubs_data):
for data in hubs_data:
data = json.loads(data.__repr__())
# print(data)
# print(data["location"])
# print(data["sequence"])
# sys.stdout.flush()
self.hubs.append(Hub(id, data["location"]))
for l in json.loads(data["sequence"]):
# print("l: ", l)
# sys.stdout.flush()
object = l
self.hubs[-1].addLayer(
SequenceLayer(object["user_id"], object["sound_id"],
object["rhythm"]))
def run(self):
hub = Hub(
self.args.src,
self.args.dst,
self.args.dst_token,
account_type=self.args.account_type,
clone_style=self.args.clone_style,
src_account_type=self.args.src_account_type,
dst_account_type=self.args.dst_account_type,
)
src_type, src_account = self.args.src.split('/')
# Using static list when static_list is set
repos = self.static_list
src_repos = repos if repos else hub.dynamic_list()
total, success, skip = len(src_repos), 0, 0
failed_list = []
for src_repo in src_repos:
# Set dst_repo to src_repo mapping or src_repo directly
dst_repo = self.mappings.get(src_repo, src_repo)
print("Map %s to %s" % (src_repo, dst_repo))
if self.test_black_white_list(src_repo):
print("Backup %s" % src_repo)
try:
mirror = Mirror(
hub,
src_repo,
dst_repo,
cache=self.args.cache_path,
timeout=self.args.timeout,
force_update=self.args.force_update,
)
mirror.download()
mirror.create()
mirror.push()
success += 1
except Exception as e:
print(e)
failed_list.append(src_repo)
else:
skip += 1
failed = total - success - skip
res = (total, skip, success, failed)
print("Total: %s, skip: %s, successed: %s, failed: %s." % res)
print("Failed: %s" % failed_list)
if failed_list:
sys.exit(1)
def default_hub(hub_name, genome, short_label, long_label, email):
"""
Returns a fully-connected set of hub components using default filenames.
"""
hub = Hub(
hub=hub_name,
short_label=short_label,
long_label=long_label,
email=email)
genome = Genome(genome)
genomes_file = GenomesFile()
trackdb = TrackDb()
hub.add_genomes_file(genomes_file)
genomes_file.add_genome(genome)
genome.add_trackdb(trackdb)
return hub, genomes_file, genome, trackdb
def init(self, hub_files):
id = 0
for f in hub_files:
with open(f, 'r') as data:
location = f.replace(".hub", "")
id += 1
self.hubs.append(Hub(id, location))
for l in data:
object = json.loads(l)
self.hubs[-1].addLayer(
SequenceLayer(object["user_id"], object["sound_id"],
object["rhythm"]))
for h in self.hubs:
print(h.getLocation())
print(h.getHubObject())
def test_delete_success(self):
r1 = self.delete_server_hub_map()
self.assertEqual(r1.status_code, server.OK)
self.assertTrue('message' in r1.json())
r2 = self.delete_server_hub_map()
self.assertEqual(r2.status_code, server.OK)
self.assertTrue('message' in r2.json())
# Place mapping back in db.
r3 = self.post_server_hub_map()
hub = Hub(restaurant_id=self.restaurant_id)
self.assertEqual(r3.status_code, server.CREATED)
self.assertTrue(hub.get_attendant_id(self.hub_id), self.attendant_id)
def __init__(self, _engine):
super(Scene, self).__init__()
if not Scene.image:
Scene.image = loadImage('data/gfx/background.png')
self._engine = _engine
self._resx, self._resy = _engine.getResolution()
self._background = pygame.transform.smoothscale(
self.image, (self._resx, self._resy))
self.surface = self._background.copy()
drawText(self.surface, "Poziom %d..." % self._engine.game['level'], 48,
(255, 255, 255), (self._resx / 2, self._resy / 2))
self._engine.show(self.surface)
self._hub = Hub(_engine)
self.planets = pygame.sprite.Group()
self.rocket = pygame.sprite.GroupSingle()
self.stars = pygame.sprite.Group()
self.canisters = pygame.sprite.Group()
self._first = True
def run_game():
""" Main game structure that runs the whole program """
# Initialize pygame
pygame.init()
# Set up the hub
hub = Hub()
pygame.display.set_caption(hub.WINDOW_TITLE)
pygame.display.set_icon(hub.WINDOW_ICON)
while True:
""" Game Loop, as long as this is true the game will run. """
# Clear Screen
hub.main_screen.fill(hub.BG_COLOR)
# Decide what screen to display
hub.display_screen()
# Display the screen onto the window
pygame.display.flip()
dt = hub.CLOCK.tick(hub.FRAMERATE)
hub.speed = 1 / float(dt)
def call_server_endpoint():
"""
Gateway for mobile notifications as initiated by a table hub.
:return: JSON response body and status code.
"""
request_body = flask.request.get_json()
# Restaurant ID and Table ID must be specified in request body.
if 'restaurant_id' in request_body:
restaurant_id = request_body['restaurant_id']
else:
request_body.update({'error': 'Restaurant ID is not specified.'})
return jsonify(request_body), BAD_REQUEST
if 'table_id' in request_body:
table_id = request_body['table_id']
else:
request_body.update({'error': 'Table ID is not specified.'})
return jsonify(request_body), BAD_REQUEST
hub = Hub(restaurant_id=restaurant_id)
user = User('')
# Get current attendant user from hub information.
attendant_id = hub.get_attendant_id(hub_id=table_id)
attendant_app_id = user.get_app_id(attendant_id)
# Get table name for message body.
table_name = hub.get_table_name(hub_id=table_id)
# Trigger notification to attendant.
success = hub.trigger_notification(attendant_app_id=attendant_app_id,
table_name=table_name)
if success:
request_body.update({'message': 'Notification Successful.'})
return jsonify(request_body), OK
else:
request_body.update({'error': 'Could not send Notification.'})
return jsonify(request_body), SERVER_ERROR
def __init__(self,
num_sensors,
num_actions,
show=True,
agent_name='test_agent'):
"""
Configure the Agent
num_sensors and num_actions are the only absolutely necessary
arguments. They define the number of elements in the
sensors and actions arrays that the agent and the world use to
communicate with each other.
"""
self.BACKUP_PERIOD = 10**4
self.show = show
self.name = agent_name
self.pickle_filename = "log/" + agent_name + ".pickle"
# TODO: Automatically adapt to the number of sensors pass in
self.num_sensors = num_sensors
self.num_actions = num_actions
# Initialize agent infrastructure
self.num_blocks = 1
first_block_name = ''.join(('block_', str(self.num_blocks - 1)))
self.blocks = [
Block(self.num_actions + self.num_sensors, name=first_block_name)
]
self.hub = Hub(self.blocks[0].max_cables)
self.action = np.zeros((self.num_actions, 1))
self.cumulative_reward = 0
self.time_since_reward_log = 0
self.reward_history = []
self.reward_steps = []
self.surprise_history = []
self.recent_surprise_history = [0.] * 100
self.timestep = 0
self.graphing = True
import config
from hub import Hub
hub = Hub(
solar_temp = None,
tank_temp = None,
tank_target_temp = config.TANK_TARGET_TEMP,
pump = False,
mode = 'auto',
)
from internet import Internet
internet = hub.add(Internet)
from temperature import Temperature
hub.add(Temperature)
from display import Display
hub.add(Display, priority=True)
from controller import Controller
hub.add(Controller, priority=True)
from pump import Pump
hub.add(Pump, priority=True)
from components.retain import Retain
hub.add(Retain)
hub.run()
# set required vdc variables before calling function
vdc.tags = config.default_tags
# all resources will be created in configuration location
resource_group_name = vdc.resource_group(config.stack)
# single hub with gateways, firewall, DMZ, shared services, bastion (optional)
hub = Hub(
'hub', # stem of child resource names (<4 chars)
HubProps(
azure_bastion=config.azure_bastion,
forced_tunnel=config.forced_tunnel,
firewall_address_space=config.firewall_address_space,
hub_address_space=config.hub_address_space,
peer=config.peer,
reference=config.reference,
resource_group_name=resource_group_name,
stack=config.stack,
subnets=[ # extra columns for future ASGs
('domain', 'any', 'any'),
('files', 'any', 'none'),
],
tags=config.default_tags,
),
)
# multiple spokes for application environments with bastion access (optional)
spoke1 = Spoke(
's01', # stem of child resource names (<6 chars)
SpokeProps(
azure_bastion=config.azure_bastion,
fw_rt_name=hub.fw_rt_name,
auto_unregister = True
for opt, val in opts:
if opt in ('-h', '--help'):
usage()
if opt == "--disable-unregister":
auto_unregister = False
if len(args) != 1:
usage("incorrect number of arguments")
instance_id = args[0]
apikey = os.getenv('HUB_APIKEY', None)
if not apikey:
fatal("HUB_APIKEY not specified in environment")
hub = Hub(apikey)
try:
server = hub.servers.get(instance_id)[0]
server.destroy(auto_unregister=auto_unregister)
except hub.Error, e:
fatal(e.description)
print fmt_server_header()
print fmt_server(server)
if __name__ == "__main__":
main()
def generateHubs(self):
hub = Hub((50, 50))
for row in range(self.gridsize):
loop = ZMQIOLoop()
loop.install()
settings = {
'xsrf_cookies': False,
'debug': True,
'autoreload': True,
'websocket_ping_interval': 60 # 定时发送ping, 保持心跳
}
app = tornado.web.Application([
(r'/ws', PushWebSocket),
], **settings)
if __name__ == '__main__':
port = '8000'
remote = '127.0.0.1:5560' # MPC 消息发布中心 发布 地址
opts, argvs = getopt.getopt(sys.argv[1:], 'r:p:')
for op, value in opts:
if op == '-r':
remote = value
if op == '-p':
port = int(value)
Hub(*remote.split(':'))
app.listen(port)
loop.start()
import hashlib
import hmac
import os
from auth import KeyProvider
from hub import Hub
# Without `pure=True`, I get an exception about str / byte issues
yaml = YAML(typ='safe', pure=True)
HERE = Path(__file__).parent
PROXY_SECRET_KEY = bytes.fromhex(os.environ['PROXY_SECRET_KEY'])
AUTH0_DOMAIN = 'yuvipanda.auth0.com'
auth0_token = KeyProvider.get_token(
AUTH0_DOMAIN, os.environ['AUTH0_MANAGEMENT_CLIENT_ID'],
os.environ['AUTH0_MANAGEMENT_CLIENT_SECRET'])
k = KeyProvider(AUTH0_DOMAIN, auth0_token)
def load_hubs():
with open(HERE / "hubs.yaml") as f:
return yaml.load(f)
hubs = load_hubs()
for hub_yaml in hubs['hubs']:
hub = Hub(hub_yaml, k, PROXY_SECRET_KEY)
hub.deploy()
def __init__(self, spec, config_path):
self.spec = spec
self.config_path = config_path
self.hubs = [Hub(self, hub_spec) for hub_spec in self.spec["hubs"]]
self.support = self.spec.get("support", {})
def order_endpoint(order_id='', restaurant_id='', customer_id='', table_id=''):
"""
Handles user- or staff-initiated requests pertaining to individual orders.
This endpoint does not handle order status.
:param order_id: Unique order ID (only for GET/PUT).
:param restaurant_id: Unique restaurant ID.
:param customer_id: Unique user ID of customer.
:param table_id: Unique hub device ID.
:return: JSON response body and status code.
"""
if request.method in ['POST', 'PUT']:
# Request has json body.
order_request = flask.request.get_json()
restaurant_id = order_request.get('restaurant_id', '')
customer_id = order_request.get('customer_id', '')
table_id = order_request.get('table_id', '')
else:
# GET request
restaurant_id = request.args.get('restaurant_id', restaurant_id)
order_id = request.args.get('order_id', order_id)
customer_id = request.args.get('customer_id', customer_id)
table_id = request.args.get('table_id', table_id)
order_request = {}
# Order ID must be non-empty.
if not order_id:
order_request.update({'error': 'Order ID must be specified.'})
return jsonify(order_request), BAD_REQUEST
if not restaurant_id:
order_request.update({'error': 'Restaurant ID is not specified.'})
return jsonify(order_request), BAD_REQUEST
if not customer_id:
order_request.update({'error': 'Customer ID is not specified.'})
return jsonify(order_request), BAD_REQUEST
if not table_id:
order_request.update({'error': 'Table ID is not specified.'})
return jsonify(order_request), BAD_REQUEST
# Restaurant must exist in database.
restaurant = Restaurant(restaurant_id=restaurant_id)
if not restaurant.exists():
order_request.update({'error': 'Specified restaurant does not exist.'})
return jsonify(order_request), BAD_REQUEST
# Customer must exist in database.
user = User('')
user.get_email(customer_id)
if not user.exists():
order_request.update({'error': 'Specified customer does not exist.'})
return jsonify(order_request), BAD_REQUEST
# Table must exist and be affiliated with the restaurant.
hub = Hub(restaurant_id=restaurant_id)
if not hub.is_registered(hub_id=table_id):
order_request.update(
{'error': 'Specified table is not registered to this restaurant.'})
return jsonify(order_request), UNAUTHORIZED
order = Order(restaurant_id=restaurant_id)
if request.method == 'GET':
order_info = order.get_order(order_id=order_id,
restaurant_id=restaurant_id,
content_type=request.content_type)
if request.content_type == 'text/csv':
return order_info
elif 'error' in order_info:
return jsonify(order_info), SERVER_ERROR
else:
return jsonify(order_info), OK
if request.method == 'POST':
# List of items must exist and must be non-empty.
if 'items' not in order_request:
order_request.update({'error': 'List of items is not specified.'})
return jsonify(order_request), BAD_REQUEST
elif len(order_request['items']) < 1:
order_request.update({'error': 'List of items is empty.'})
return jsonify(order_request), BAD_REQUEST
order_response = order.place_order(order=order_request,
customer_id=customer_id,
table_id=table_id)
if 'error' in order_response:
return jsonify(order_response), SERVER_ERROR
else:
return jsonify(order_response), OK
if request.method == 'PUT':
# PUT -> update order (insert/update)
pass
def server_hub_map_endpoint(restaurant_id='', attendant_id=''):
"""
Handles updates to waitstaff/table mappings, which is used for
mobile notifications.
:return: JSON response body and status code.
"""
if request.method == 'POST':
# POST Request.
request_body = flask.request.get_json()
restaurant_id = request_body.get('restaurant_id', '')
elif request.method == 'GET':
# GET Request.
restaurant_id = request.args.get('restaurant_id', restaurant_id)
request_body = {}
else:
# DELETE Request.
restaurant_id = request.args.get('restaurant_id', restaurant_id)
attendant_id = request.args.get('attendant_id', attendant_id)
request_body = {}
# Restaurant ID must be specified.
if not restaurant_id:
request_body.update({'error': 'Restaurant ID not specified.'})
return jsonify(request_body), BAD_REQUEST
restaurant = Restaurant(restaurant_id=restaurant_id)
if not restaurant.exists():
request_body.update({'error': 'Specified restaurant does not exist.'})
return jsonify(request_body), BAD_REQUEST
if request.method == 'POST':
# update keys.
if 'mappings' not in request_body:
request_body.update({'error': 'Mappings not specified.'})
return jsonify(request_body), BAD_REQUEST
elif len(request_body['mappings']) < 1:
request_body.update({'error': 'Mappings list is empty.'})
return jsonify(request_body), BAD_REQUEST
mappings = request_body['mappings']
for mapping in mappings:
user = User('')
user_id = mapping.get('attendant_id', '')
user.get_email(user_id=user_id)
hub = Hub(restaurant_id=restaurant_id)
hub_id = mapping.get('table_id', '')
# User must exist, and be associated with the specified restaurant.
if not user.exists():
request_body.update({
'error':
'Specified user {} does not exist.'.format(user_id)
})
return jsonify(request_body), BAD_REQUEST
elif user.get_my_restaurant(user_id=user_id) != restaurant_id:
request_body.update({
'error':
'Specified user {} is not affiliated with specified restaurant.'
.format(user_id)
})
return jsonify(request_body), UNAUTHORIZED
# Specified hub must be associated with the specified restaurant.
if not hub.is_registered(hub_id=hub_id):
request_body.update({
'error':
'Specified table ID {} is not affiliated with specified restaurant.'
.format(hub_id)
})
return jsonify(request_body), UNAUTHORIZED
mapping_info = restaurant.update_staff_hub_mappings(
mapping_info=request_body)
return jsonify(mapping_info), CREATED
elif request.method == 'GET':
# GET all mappings in restaurant (with emails).
mappings = restaurant.get_staff_hub_mappings()
request_body.update(mappings)
if 'error' in mappings:
return jsonify(request_body), SERVER_ERROR
else:
return jsonify(request_body), OK
elif request.method == 'DELETE':
# Attendant ID must be specified.
if not attendant_id:
request_body.update({'error': 'User ID not specified.'})
return jsonify(request_body), BAD_REQUEST
user = User('')
user.get_email(user_id=attendant_id)
# Specified user must exist and be associated with the specified restaurant.
if not user.exists():
request_body.update({'error': 'Specified user does not exist.'})
return jsonify(request_body), BAD_REQUEST
elif user.get_my_restaurant(user_id=attendant_id) != restaurant_id:
request_body.update(
{'error': 'User restaurant combination does not match.'})
return jsonify(request_body), UNAUTHORIZED
response = restaurant.remove_staff_from_mappings(staff_id=attendant_id)
request_body.update(response)
if 'error' in response:
return jsonify(response), SERVER_ERROR
else:
return jsonify(response), OK
ref = f'{org}/{project}/{peer}'
else:
ref = None
# single hub virtual network with gateway, firewall, DMZ and shared services
hub = Hub(
'hub', # stem of child resource names (<4 chars)
HubProps(
resource_group_name=resource_group_name,
tags=default_tags,
stack=stack,
dmz_ar=config.require('firewall_dmz_subnet'),
fwm_ar=config.get('firewall_management_subnet'),
fws_ar=config.require('firewall_subnet'),
fwz_as=config.require('firewall_address_space'),
gws_ar=config.require('hub_gateway_subnet'),
hbs_ar=config.get('hub_bastion_subnet'),
hub_ar=config.require('hub_first_subnet'),
hub_as=config.require('hub_address_space'),
peer=peer,
ref=ref,
subnets=[ # extra columns for future NSGs
('domain', 'any', 'any'),
('files', 'any', 'none'),
],
),
)
# multiple spoke virtual networks for application environments
spoke1 = Spoke(
's01', # stem of child resource names (<6 chars)
SpokeProps(
import config
from hub import Hub
hub = Hub(
valve_open = False,
)
from ball_valve import BallValve
valve = hub.add(BallValve)
batt_low = False
if config.BATT:
from components.battery import Battery
hub.add(Battery)
batt_low = valve.check_battery(hub)
if not batt_low:
if config.BTN:
from button import Button
hub.add(Button)
from internet import Internet
internet = hub.add(Internet)
hub.run()
import config
from hub import Hub
hub = Hub(
count=-1,
battery=100,
)
from internet import Internet
internet = hub.add(Internet)
from counter import Counter
hub.add(Counter)
if config.BATT:
from components.battery import Battery
hub.add(Battery)
hub.run()
import config
from hub import Hub
hub = Hub(
light=False,
light_cmd=False,
brightness=config.INIT_BRI,
motion=False,
enable=False,
auto=False,
battery=100,
)
config.RETAIN = set(('light', ))
if config.BRIGHTNESS:
config.RETAIN.add('brightness')
if config.BATT:
config.RETAIN.add('battery')
if config.MOTN:
config.RETAIN.add('auto')
config.RETAIN.add('enable')
if len(config.RETAIN) > 0:
from components.retain import Retain
hub.add(Retain)
from light import Light
hub.add(Light, priority=True) # put light above retain
stack = get_stack()
default_tags = {'environment': stack}
# all resources will be created in the Resource Group location
resource_group = core.ResourceGroup(
stack + '-vdc-rg-',
tags=default_tags,
)
# Hub virtual network with gateway, firewall, DMZ and shared services subnets
hub1 = Hub(
config.require('hub_stem'),
HubProps(
config=config,
resource_group=resource_group,
tags=default_tags,
stack=stack,
),
opts=ResourceOptions(
custom_timeouts=CustomTimeouts(create='1h', update='1h', delete='1h')),
)
# Spoke virtual network for application environments
spoke1 = Spoke(
config.require('spoke_stem'),
SpokeProps(
config=config,
resource_group=resource_group,
tags=default_tags,
hub=hub1,
),