def test_department_give_raises():
bruce = manager.Manager('Bruce', 'Programmer', 100)
sue = person.Person('Sue', 'Assistant', 100)
accounting = department.Department(bruce, sue)
accounting.give_raises(.10)
assert bruce.pay == 120
assert sue.pay == 110
def __init__(self):
# 实例化 管理器、下载器、解析器、输出器
self.manager = manager.Manager()
self.download = download.Download()
self.parser = parser.Parser()
self.output = output.Output()
def main():
args = parse_args()
logging.basicConfig(
level=args.loglevel,
format='%(name)s [%(process)d] %(levelname)s %(message)s')
if args.loglevel and not args.debug_requests:
logging.getLogger('requests').setLevel(logging.WARN)
LOG.info('Starting up')
LOG.info('Kubernetes is %s', args.kube_endpoint)
LOG.info('Etcd is %s', args.etcd_endpoint)
LOG.info('Managing interface %s', args.interface)
if args.no_driver:
iface_driver = None
fw_driver = None
else:
iface_driver = interface.Interface(args.interface)
fw_driver = firewall.Firewall(fwchain=args.fwchain, fwmark=args.fwmark)
mgr = manager.Manager(etcd_endpoint=args.etcd_endpoint,
kube_endpoint=args.kube_endpoint,
etcd_prefix=args.etcd_prefix,
iface_driver=iface_driver,
fw_driver=fw_driver,
cidr_ranges=args.cidr_range,
refresh_interval=args.refresh_interval,
id=args.agent_id)
LOG.info('My id is: %s', mgr.id)
mgr.run()
def server():
service_status = ForgeService().status()
mods = manager.Manager(FORGEDIR).get_installed_mods()
# service_status = b'active'.decode("utf-8")
return render_template(
"server.html", service_status=service_status, installed_mods=mods
)
def main():
# preparing:
parser = CreateParser()
arguments = parser.parse_args( sys.argv[1:] )
if( ( not os.path.isdir( arguments.src ) ) or ( not os.path.isdir( arguments.dst ) ) ):
print( "Error: --src and --dst values must be directories!" )
return
print( arguments )
freezer_name_a = "spfs_switcher_active"
freezer_name_r = "spfs_switcher_retired"
abs_src = os.path.abspath( arguments.src )
abs_dst = os.path.abspath( arguments.dst )
mnt_src = FindMountPoint( abs_src )
mnt_dst = FindMountPoint( abs_dst )
if( mnt_src == mnt_dst ):
print( "Error: --src and --dst directories must be on different mount points!" )
return
RsyncCall( abs_src, abs_dst )
PutProcessesIntoFreezer( arguments.pid, freezer_name_a )
RsyncCall( abs_src, abs_dst )
mngr = manager.Manager("./control.sock")
mngr.switch( source=abs_src, target=abs_dst, freeze_cgroup=FreezerPath( freezer_name_a ) )
# mngr.mount(id=0, mountpoint="./mount-dir", mode="proxy", proxy_dir="./proxy-dir")
PutProcessesIntoFreezer( ParseTasks( freezer_name_a ), freezer_name_r )
def test_multiple_give_raise():
bruce = manager.Manager('Bruce', 'Programmer', 100)
sue = person.Person('Sue', 'Assistant', 100)
for obj in (bruce, sue):
obj.give_raise(.10)
assert bruce.pay == 120
assert sue.pay == 110
def generate_graph_example():
g = m.Manager()
'''g.set_Configuration(layerNum = 4,layerNodeNum = [48,50,100,100], outputPath = "../connection_data/",
conPara = {"1,1": 150,"1,2": 230,"2,2": 350,"2,3": 60,"3,3":60,"3,4":10,"4,4":16},
conDisPara= {"1,1": 1.5,"1,2": 1.5,"2,2": 1.5,"2,3": 1.5,"3,3":1.5,"3,4":1.5,"4,4":1.5},
graphName = "example")'''
g.set_Configuration(layerNum=4,
layerNodeNum=[8, 5, 10, 10],
outputPath="../../mininet-manager/",
conPara={
"1,1": 15,
"1,2": 23,
"2,2": 35,
"2,3": 6,
"3,3": 6,
"3,4": 1,
"4,4": 8
},
conDisPara={
"1,1": 1.5,
"1,2": 1.5,
"2,2": 1.5,
"2,3": 1.5,
"3,3": 1.5,
"3,4": 1.5,
"4,4": 1.5
},
graphName="example2")
g.generate_Graph()
print("Success")
def main(actions=None):
CONF(sys.argv[1:], project='publisher',
version=version.version_info.release_string())
logging.basicConfig(level=logging.INFO)
LOG = logging.getLogger(__name__)
try:
if CONF.input_data:
# data = json.loads(CONF.input_data)
print("hello")
data = "Hello-data"
else:
with open(CONF.input_data_file) as f:
text = f.read()
data = "Bye-data"
print("Bye")
print(text)
LOG.debug('Input data: %s', data)
mgr = manager.Manager(data)
if actions:
for action in actions:
getattr(mgr, action)()
except Exception as exc:
handle_exception(exc)
def main():
# CLI options
argparser = argparse.ArgumentParser(description='EdgeAP management server')
argparser.add_argument(
'-c',
'--config',
type=str,
default="manager.conf",
help='configuration file (default is "manager.conf")')
args = argparser.parse_args()
config_file = args.config
# Create manager object
man_obj = manager.Manager(config_file)
# Signal handler
def handler(signal, frame):
print("Error: received signal ", signal, file=sys.stderr)
print("Shutting down...", file=sys.stderr)
man_obj.shutdown()
sys.exit(0)
# Register all catchable signals
catchable_sigs = set(
signal.Signals) - {signal.SIGKILL, signal.SIGSTOP, signal.SIGWINCH}
for sig in catchable_sigs:
signal.signal(sig, handler)
# Start the manager servers
man_obj.start_request_server()
man_obj.start_shutdown_server()
# Join threads
for _, thread in man_obj.threads.items():
thread.join()
def setUp(self):
self.cachedir = os.path.join('..', 'cachetest')
self.manager = manager.Manager(cachedir=self.cachedir, pushurl='http://127.0.0.1/')
self.manager.clearcache()
self.rssurl = 'testrss.xml'
self.rss = rssmodule.RSS(self.rssurl)
self.rssitems = self.rss.getitems()
def main():
master = tk.Tk()
master.title("Chess")
master.geometry("+20+20")
master.configure(bg="#FFFFFF")
manager.Manager(master)
master.mainloop()
def setUp(self):
self.searchkey = 'devops'
self.year = '2017'
self.rssurl = 'testrss.xml'
self.cachedir = os.path.join('..', 'cachetest')
self.manager = manager.Manager(cachedir=self.cachedir)
self.manager.clearcache()
def __init__(self, id):
'''
id is 1 indexed
'''
self.id = id
self.role = 'Peasant'
self.hand = cards.Hand()
self.manager = manager.Manager()
def __init__(self):
self.tileWidth = 50
self.tileHeight = 50
self.tileSet = []
self.entities = manager.Manager()
def __init__(self):
self.fpsManager = fps.FPSManager(60)
ika.SetCaption("TRIBAL")
self.lastUpdate = 0
self.lastFPS = 0
self.currentFrame = 0
self.objectList0 = manager.Manager()
self.objectList1 = manager.Manager()
self.objectList2 = manager.Manager()
self.objectLists = [
self.objectList0, self.objectList1, self.objectList2
]
def main():
employee = [em.Employee('Sadou', 4500),em.Employee('Madian', 2500), em.Employee('Ismaila', 2000)]
manager = mn.Manager('Thierno', 6000)
manager.hire_employee('Ibrahim', 2500)
manager.display_info()
for emp in employee:
emp.display_info()
def __init__(self):
super().__init__()
self.setupUi(self)
# self.overlayClass = overlay_2.Sticker('red.gif', xy=[300, 300], size=0.3, on_top=True)
self.processmanager = manager.Manager()
# push button 이벤트 click listener
self.analysisStartBtn.clicked.connect(self.analysisStartBtn_clicked)
self.analysisEndBtn.clicked.connect(self.analysisEndBtn_clicked)
def __init__(self, proxydb=None, sharestats=None):
self.proxies = proxydb
self.shares = sharestats
self.rm_shares = {}
self.shutdown = False
self.log = Log.Log("control")
self.listen_ip = "127.0.0.1"
self.listen_port = 2222
self.manager = manager.Manager()
def get_manager(self):
"""reload the manager class
"""
self.deep_module_reload(is_verb=False)
import manager as manager
manager = manager.Manager()
return manager
def try_connect(self):
self._manager = manager.Manager()
try:
self._manager.connect(self._manager_host)
self._manager.login(self._manager_login, self._manager_passw)
except manager.ManagerSocketException, (errno, reason):
logging.error("Error connecting to the manager: %s" % reason)
#sys.exit(1)
return False
def test_all(self):
order = { 'first_name' : 'Test',
'last_name' : 'User',
'email' : '*****@*****.**',
'phone' : '919-123-4567',
'label' : '123 Main St.',
'locality' : 'Raleigh',
'region' : 'NC',
'postal_code' : '27609',
'country' : 'US',
'shipment_method' : 'FedEx Express Saver',
'line_items' : [
{'sku' : 'CCUPEN', 'quantity' : '2'},
{'sku' : 'CCUPAD', 'quantity' : '1'}]
}
order_id = manager.Manager().register_order(**order)
ret = manager.Manager().flush()
self.assertEquals(len(ret['failure']), 0)
self.assertEquals(len(ret['success']), 1)
def main(debug=False):
try:
util.load_logging_system()
logger = logging.getLogger(__name__)
config = util.get_config()
pidfile = config.get("PATH", "pid")
pid = os.getpid()
open(pidfile, 'w').write("%d" % pid)
manager.Manager(debug).run()
except Exception, ex:
logger.exception("Houston, we have a problem!")
def handle(self):
client.start()
while True:
print("waiting connection")
connection, address = self.socket.accept()
print("connection is set...")
kill_event = threading.Event()
sender = threading.Thread(target=sender_subscriber, args=(client.q, connection, kill_event), daemon=True)
manag = manager.Manager(client.q, connection, kill_event)
manag.start()
sender.start()
manag.join()
sender.join()
def create_manager(hostname, username, password):
"""
Creates and returns a manager for the OpenWRT instance for the specified information.
Args:
hostname: the hostname to the OpenWRT instance
username: the configured Luci username
password: the configured luci password
Raises:
AuthenticationError: any call can raise this when authentication fails
"""
import manager
return manager.Manager(hostname, username, password)
def backmenu(self):
self.destroy()
self.cur.execute("select designation from employees where empid = :1",
(self.empid, ))
res = self.cur.fetchall()
des = res[0][0]
if des == "MANAGER":
x = manager.Manager(self.empid, self.cur)
x.back("Menu")
elif des == "ADMIN":
x = admin.Admin(self.empid, self.cur)
x.back("Menu")
def __init__(self, pool, sharestats=None, identifier=None):
self.pool = pool
self.miners_queue = {}
self.pool_queue = queue.Queue()
self.pool_queue.put("")
self.pool.setblocking(0)
if not identifier:
identifier = str(id(self.miners_queue))[10:]
self.id = identifier
self.log = log.Log("pxy"+self.id)
self.new_conns = []
self.shares = sharestats
self.manager = manager.Manager(sharestats=self.shares, identifier="mng"+self.id)
self.shutdown = False
def test_manager(self):
pl1, pl2 = get_two_players({
'red': 0,
'blue': 1
}, {
'red': 1,
'blue': 1
})
interact = Interaction.Interaction(self.table)
interact.interact(pl1, pl2)
players = [pl1, pl2]
Uni = Interaction.Universe(players, interact)
manag = manager.Manager(Uni)
manag.plot_and_update()
def testDesign(designPath):
m = manager.Manager(gui = None)
m.errorOccurred.connect(errorHandler)
m.openDesign(designPath)
m.executionMode = backend.BACKEND_MODELSIM
(instanceNum, stateNum) = m.currentState
f = m.design.getFunctionFromInstanceNum(instanceNum)
assert f.name == "main"
# We start in state 0 for an instrumented design and state 1 for non-instrumented
# (should probably look into the reason for this difference. Likely due to how the circuits are started).
assert stateNum == 0 or stateNum == 1
m.run()
# Make sure we can still get the current state
(instanceNum, stateNum) = m.currentState
m.closeDesign()
def try_connect (self):
# logging.debug("OutBound Server try_connect : "+self._voipserver_host+" - server_type : "+str(self._voipserver_server_type))
# Asterisk
if (self._voipserver_server_type == 1) :
# instance Manager
self._voipserver = manager.Manager()
# connect & login with Asterisk
try :
self._voipserver.connect(self._voipserver_host);
self._voipserver.login(self._voipserver_login, self._voipserver_passw);
except manager.ManagerSocketException, (errno, reason):
#logging.info("Error connecting to the manager: %s" % reason);
raise
except manager.ManagerAuthException, reason:
#logging.info("Error logging in to the manager: %s" % reason);
raise
def lock(self):
if self.is_lock(): return
self.write_lock.acquire()
self.__lock = True
# add default manager
for name, index_models in self.candidate.items():
for index_model in index_models:
__index_model = index_model()
setattr(
index_model,
"objects",
manager.Manager(),
)
getattr(index_model,
"objects").contribute_to_class_index_model(
__index_model,
"objects",
)
# attach `create_index` method.
manager.MethodCreateIndex.analyze_model_manager(
__index_model._meta.model, )
# attach signals
for sig in constant.SIGNALS:
signals.Signals.connect(
sig,
model=__index_model._meta.model,
)
#super(ModelsRegisteredDict, self).__setitem__(name, __index_model)
self.setdefault(name, list())
self[name].append(__index_model)
self.index_models[index_model.__name__] = __index_model
self.candidate.clear()
self.write_lock.release()
