#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.user_script_forker import UserScriptForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(UserScriptForker,
single_threaded=True,
state_name="user_script_forker")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
from Cobalt.Components.bb import BBSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BBSystem, register=True)
except KeyboardInterrupt:
SystemExit(1)
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.bg_mpirun_forker import BGMpirunForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGMpirunForker, single_threaded=True, state_name="bg_mpirun_forker")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
from Cobalt.Components.simulator import Simulator
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(Simulator, state_name='brooklyn',
cls_kwargs={'config_file':'simulator.xml'})
except KeyboardInterrupt:
pass
def main ():
cpm = ProcessManager()
run_component(cpm)
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Heckle Cobalt Interface component reference
...I don't really know what this does...
"""
from Cobalt.Components.heckle_system2 import HeckleSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(HeckleSystem, register=True)
except KeyboardInterrupt:
SystemExit(1)
#!/usr/bin/env python
# $Id$
from Cobalt.Components.system.CraySystem import CraySystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(CraySystem, register=True, state_name="alpssystem")
except KeyboardInterrupt:
pass
#!/usr/bin/env python
__revision__ = '$Revision: 1 $'
import sys
from Cobalt.Components.DBWriter.cdbwriter import MessageQueue
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(MessageQueue, register=True, state_name='cdbwriter')
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.base import run_component
from Cobalt.Components.heckle_forker import HeckleForker
if __name__ == "__main__":
try:
run_component(HeckleForker, single_threaded=True)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.heckle_sched import HeckleSched
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(HeckleSched, state_name='bgsched')
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
from Cobalt.Components.gravina import BGSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGSystem, state_name='gravina',
cls_kwargs={'config_file':'bgq_simulator.xml'})
except KeyboardInterrupt:
pass
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.user_script_forker import UserScriptForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(UserScriptForker, single_threaded=True, state_name="user_script_forker")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.system_script_forker import SystemScriptForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(SystemScriptForker, single_threaded=True, state_name="system_script_forker")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.system_script_forker import SystemScriptForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(SystemScriptForker,
single_threaded=True,
state_name="system_script_forker")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
import sys
from Cobalt.Components.histm import HistoryManager
from Cobalt.Components.base import run_component
__helpmsg__ = "Usage: histm [-j <jobinfo_file> -d <last_days> -d <least_item> -i <update_interval (in sec)>]"
if __name__ == "__main__":
options = {}
doptions = {
'j': 'jobinfo_file',
'd': 'last_days',
'n': 'least_item',
'i': 'update_interval'
}
try:
run_component(HistoryManager, register=True, state_name='histm')
except KeyboardInterrupt:
sys.exit(1)
def __init__(self, *args, **kwargs):
Component.__init__(self, *args, **kwargs)
@exposed
def catchMessage(self, msg):
# sleep(30)
print "I got a message: %s" % msg
# raise RuntimeError("BQQM!")
def delay(self):
print "starting sleep cycle"
print ctime()
sleep(300)
# i = 0
# while(i < 100000000):
# i += 1.0
print "sleep cycle complete"
print ctime()
# delay = automatic(delay, 10)
if __name__ == "__main__":
try:
run_component(RetransRecv, single_threaded=True)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Heckle Cobalt Interface component reference
...I don't really know what this does...
"""
from Cobalt.Components.heckle_system import HeckleSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(HeckleSystem, register=True)
except KeyboardInterrupt:
SystemExit(1)
#!/usr/bin/python
import sys
from Cobalt.Components.histm import HistoryManager
from Cobalt.Components.base import run_component
__helpmsg__ = "Usage: histm [-j <jobinfo_file> -d <last_days> -d <least_item> -i <update_interval (in sec)>]"
if __name__ == "__main__":
options = {}
doptions = {'j':'jobinfo_file', 'd':'last_days', 'n':'least_item',
'i':'update_interval'}
try:
run_component(HistoryManager, register=True, state_name='histm')
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.base_forker import BaseForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BaseForker, single_threaded=True)
except KeyboardInterrupt:
sys.exit(1)
def main():
cpm = ProcessManager()
run_component(cpm)
#!/usr/bin/python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.scriptm import ScriptManager
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(ScriptManager)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/python
# $Id$
import sys
from Cobalt.Components.cluster_system import ClusterSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(ClusterSystem, register=True, state_name="cluster_system")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
__revision__ = "$Revision: $"
import sys
from Cobalt.Components.bg_runjob_forker import BGRunjobForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGRunjobForker, single_threaded=True, state_name="bg_runjob_forker")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/python2.6
# $Id$
import sys
from Cobalt.Components.orcm_system import OrcmSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
# myorcm = OrcmSystem()
try:
# run_component(OrcmSystem, register=True, state_name="orcm_system")
run_component(OrcmSystem, register=True)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/python
# $Id$
import sys
from Cobalt.Components.cluster_system import ClusterSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(ClusterSystem,
register=True,
state_name="cluster_system")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
from Cobalt.Components.cluster_simulator import Simulator
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(Simulator, state_name="cluster_simulator")
except KeyboardInterrupt:
pass
#!/usr/bin/python
from Cobalt.Components.bbsim import BBSimulator
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BBSimulator, register=True)
except KeyboardInterrupt:
SystemExit(1)
#!/usr/bin/env python
__revision__ = '$Revision: 1981 $'
import sys
from Cobalt.Components.slp import TimingServiceLocator
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(TimingServiceLocator, register=False)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.bg_runjob_forker import BGRunjobForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGRunjobForker,
single_threaded=True,
state_name="bg_runjob_forker")
except KeyboardInterrupt:
sys.exit(1)
from time import sleep
from Cobalt.Components.base import Component, run_component, exposed, automatic
from Cobalt.Proxy import ComponentProxy
class RetransSend(Component):
name = "RetSend"
implementation = "RetSend"
def __init__ (self, *args, **kwargs):
Component.__init__(self, *args, **kwargs)
self.count = 0
def sendMessage(self):
self.count += 1
print "Sending Message: seq %d" % self.count
ComponentProxy("RetRecv", defer=False, retry=False).catchMessage("messgae %d caught." % self.count)
sendMessage = automatic(sendMessage, 10)
if __name__ == "__main__":
try:
run_component(RetransSend)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
__revision__ = '$Revision$'
import sys
from Cobalt.Components.cqm import QueueManager
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(QueueManager, register=True, state_name='cqm')
except KeyboardInterrupt:
sys.exit(1)
def __init__(self, *args, **kwargs):
Component.__init__(self, *args, **kwargs)
@exposed
def catchMessage(self, msg):
#sleep(30)
print "I got a message: %s" % msg
#raise RuntimeError("BQQM!")
def delay(self):
print "starting sleep cycle"
print ctime()
sleep(300)
#i = 0
#while(i < 100000000):
# i += 1.0
print "sleep cycle complete"
print ctime()
#delay = automatic(delay, 10)
if __name__ == "__main__":
try:
run_component(RetransRecv, single_threaded=True)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
from Cobalt.Components.bgqsystem import BGSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGSystem, state_name='bgqsystem')
except KeyboardInterrupt:
pass
#!/usr/bin/env python
from Cobalt.Components.simulator import Simulator
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(Simulator,
state_name='brooklyn',
cls_kwargs={'config_file': 'simulator.xml'})
except KeyboardInterrupt:
pass
#!/usr/bin/env python
__revision__ = '$Revision: 1140 $'
import sys
from Cobalt.Components.slp import TimingServiceLocator
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(TimingServiceLocator, register=False)
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/python
# $Id$
import sys
from Cobalt.Components.bgsystem import BGSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGSystem, register=True, state_name='bgsystem')
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.bg_mpirun_forker import BGMpirunForker
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGMpirunForker,
single_threaded=True,
state_name="bg_mpirun_forker")
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
from Cobalt.Components.gravina import BGSystem
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGSystem,
state_name='gravina',
cls_kwargs={'config_file': 'bgq_simulator.xml'})
except KeyboardInterrupt:
pass
#!/usr/bin/env python
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.bgsched import BGSched
from Cobalt.Components.base import run_component
if __name__ == "__main__":
try:
run_component(BGSched, state_name='bgsched')
except KeyboardInterrupt:
sys.exit(1)
#!/usr/bin/env python
'''Launcher for alps_script_forkers. If we are running multiple on a node,
this will spawn the actual forkers as subprocesses.
'''
__revision__ = '$Revision: $'
import sys
from Cobalt.Components.alps_script_forker import ALPSScriptForker
from Cobalt.Components.base import run_component
#from Cobalt.Util import init_cobalt_config, get_config_option
if __name__ == "__main__":
# state_name = 'alps_script_forker'
# if '--name' in sys.argv:
# state_name = sys.argv[sys.argv.index('--name') + 1]
seq_num = 0
if '--seq' in sys.argv:
seq_num = sys.argv[sys.argv.index('--seq') + 1]
sys.argv.remove('--seq')
sys.argv.remove(seq_num)
seq_num = int(seq_num)
try:
run_component(ALPSScriptForker, single_threaded=True,
aug_comp_name=True, state_name_match_component=True,
seq_num=seq_num)
except KeyboardInterrupt:
sys.exit(1)
