def main(options, args):
# Make top-level logger.
logger = ssdlog.make_logger('ut1-utc', options)
today = time.strftime("%Y%M%d", time.localtime())
oldfile = os.path.join(dbarea, filename)
bakfile = os.path.join(dbarea, filename + '.bak')
newfile = os.path.join(dbarea, filename + '.' + today)
res = os.system("wget --tries=5 -O %s %s" % (newfile, options.url))
if res == 0:
try:
os.remove(bakfile)
except OSError:
pass
try:
os.rename(oldfile, bakfile)
os.rename(newfile, oldfile)
except Exception, e:
logger.error("Failed to ftp ut1-utc file: %s" % url)
logger.error(str(e))
sys.exit(1)
def main(options, args):
logname = 'summit_ups'
logger = ssdlog.make_logger(logname, options)
power_off = 'obcpPoff'
power_off = os.path.join(options.dir, power_off)
try:
os.remove(power_off)
except Exception as e:
logger.warn('warn: is %s there?? %s' % (power_off, e))
snmp = SnmpTrap(power_off, logger)
try:
transportDispatcher = AsynsockDispatcher()
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(
('%s' % options.mgrhost, 162)))
transportDispatcher.registerRecvCbFun(snmp.trap_cb)
transportDispatcher.jobStarted(1) # this job would never finish
transportDispatcher.runDispatcher()
except KeyboardInterrupt:
logger.info('keyboard interrupting...')
snmp.ev_quit.set()
except Exception as e:
logger.error('error: %s' % e)
snmp.ev_quit.set()
logger.error('error: snmp trap terminated..')
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('plot', options)
class AppWindow(QtGui.QMainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.resize(350, 350)
self.main_widget = QtGui.QWidget()
l = QtGui.QVBoxLayout(self.main_widget)
l.setMargin(0)
l.setSpacing(0)
#sc = MyStaticMplCanvas(self.main_widget, width=5, height=5, dpi=None)
if options.mode == 'ag':
plot = AgPlot(self.main_widget, logger=logger)
#aplot=AOPlot1(self.main_widget, logger=logger)
elif options.mode == 'fmos':
plot = FmosPlot(self.main_widget, logger=logger)
elif options.mode == 'nsopt' or options.mode == 'hsc':
plot = TwoGuidingPlot(self.main_widget, logger=logger)
elif options.mode == 'nsir':
plot = NsIrPlot(self.main_widget, logger=logger)
else:
logger.error('error: mode=%s' % options.mode)
sys.exit(1)
#l.addWidget(sc)
#zoomin = QtGui.QPushButton(QtGui.QIcon.fromTheme('zoom-in'), 'Zoom In')
l.addWidget(plot)
##l.addWidget(aplot)
##l.addWidget(zoomin)
timer = QtCore.QTimer(self)
QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"),
plot.tick)
timer.start(options.interval)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
self.statusBar().showMessage("%s starting..." % options.mode, 5000)
#print options
def closeEvent(self, ce):
self.close()
try:
qApp = QtGui.QApplication(sys.argv)
aw = AppWindow()
aw.setWindowTitle("%s" % progname)
aw.show()
sys.exit(qApp.exec_())
except KeyboardInterrupt, e:
logger.warn('keyboard interruption....')
sys.exit(0)
def main(options, args):
logger = ssdlog.make_logger('launcher', options)
# Create the scanner
scanner = launcherScanner(logger=logger, debug=0, lextab=lex_tab_module)
# Create the parser
parser = launcherParser(scanner,
logger=logger,
debug=1,
tabmodule=yacc_tab_module)
if len(args) > 0:
for filename in args:
try:
if options.action == 'scan':
res = scanner.scan_file(filename)
if (res.tokens != None) and options.verbose:
printTokens(res.tokens)
elif options.action == 'parse':
res = parser.parse_file(filename)
if (res != None) and options.verbose:
pprint.pprint(res)
else:
raise ScanError("I don't understand action='%s'" %
(options.action))
except (ScanError, ParseError), e:
# Print error message and continue to next file
logger.error(str(e))
def main(options, args):
"""Main program. _options_ is an OptionParser object that holds parsed
options. _args_ is a list of the remaining non-option parameters.
"""
# Create top level logger.
logger = ssdlog.make_logger('INSintTester', options)
# Only import and initialize remoteObjects if we are trying to
# use Gen2 services
if options.monitor or options.statussvc:
ro.init()
# Create app and display
app = INSintTester(options, logger)
app.show()
# TODO: find a better way to keep these dialogs suppressed at
# startup.
sw = app.widgets['setup_obcp']
sw.window.hide()
sw = app.widgets['dialog_filechooser']
sw.window.hide()
# Enter GUI event-processing loop.
while not app.ev_mainquit.isSet():
# Process X events
while gtk.events_pending():
gtk.main_iteration()
# Sleep and let other threads run
time.sleep(0.25)
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('bootmgr', options)
# Create the boot manager
bootmgr = BootManager(logger,
mgrport=options.mgrport,
monsvc=options.monitor,
confpfx=options.confpfx)
# Show possible configurations
# NOTE: this won't work unless a module is loaded
if options.showconfigs:
print "Available configurations: %s" % str(bootmgr.getConfigs())
sys.exit(0)
if options.configname:
# Try to load the specified config
try:
bootmgr.loadConfig(options.configname)
except BootError, e:
print str(e)
print "Available configurations: %s" % str(bootmgr.getConfigs())
sys.exit(1)
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('hskymon', options)
### Start the legacy viewer ###
# Flags that record what has been started, to effect an orderly
# shutdown--see quit(). We declare variables here so that quit
# is closed in their lexical scope.
viewproc = None
# This function is called if we receive a signal, terminate the app,
# etc.
def quit(exitcode):
if viewproc:
logger.info("Stopping hskymon viewer.")
try:
viewproc.killpg()
except Exception, e:
# If user used a normal exit mechanism from GUI then
# trying to kill it here raises an error.
if str(e) != "[Errno 3] No such process":
logger.error("Error stopping subprocesses: %s" % str(e))
exitcode = 1
# logger.close() ??
sys.exit(exitcode)
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('sk_skcompile', options)
if options.skdir:
skdir = options.skdir
else:
try:
skdir = os.path.join(os.environ['PYHOME'], 'SOSS', 'SkPara', 'sk')
except KeyError:
print "Please set your PYHOME environment variable"
print "or specify the --skdir option"
sys.exit(1)
sk_bank = sk_interp.skBank(skdir, logger=logger)
compiler = SkCompiler(sk_bank, logger, append_mode=options.appendmode)
obe_id = args[0].upper()
obe_mode = args[1].upper()
for cmd in args[2:]:
print compiler.compile_skeleton(obe_id, obe_mode, cmd)
compiler.append_mode = True
return 0
def main(options, args):
logname = 'star_list'
# Create top level logger.
logger = ssdlog.make_logger(logname, options)
try:
ra = float(options.ra)
dec = float(options.dec)
fov = float(options.fov)
uppermag = float(options.uppermag)
lowermag = float(options.lowermag)
except Exception as e:
print 'need args. %s' % str(e)
sys.exit(1)
if lowermag >= uppermag:
print 'upper mag should be greater than lower mag'
sys.exit(1)
catalog = options.catalog
if options.dbhost:
dbhost = options.dbhost
else:
try:
dbhost = os.environ['DBHOST']
except KeyError, e:
dbhost = 'g2db'
def main(options, args):
logname = 'sendlog'
logger = ssdlog.make_logger(logname, options)
ro.init()
tm = ro.remoteObjectProxy('taskmgr0')
tm.loadModule('LOGTask')
tm.addAllocs(['STARS'])
today = datetime.date.today()
one_day = datetime.timedelta(days=1)
yesterday = today - one_day
if not options.fromdate:
obs_time_from = '%s 17:00:00' % (yesterday)
day_time_from = '%s 08:00:00' % (yesterday)
else:
obs_time_from = options.fromdate
day_time_from = options.fromdate
if not options.todate:
obs_time_to = '%s 08:00:00' % (today)
day_time_to = '%s 17:00:00' % (yesterday)
else:
obs_time_to = options.todate
day_time_to = options.fromdate
try:
logdir = os.environ['LOGHOME']
except KeyError, e:
logdir = '/gen2/logs'
def main(options, args):
"""Main program. Set up the logger, create a dbtool object and invoke
a method on it.
"""
# Create top level logger.
logger = ssdlog.make_logger('dbtool', options)
if not options.target:
logger.error("Please specify a --target !")
return
dbtools = []
for target in options.target.split(','):
try:
dbtools.append(DbTool(logger, dbhosts[target]))
except KeyError:
logger.error("--target must include one or more of %s" % (
str(dbhosts.keys())))
return
try:
for dbtool in dbtools:
dispatch(dbtool, options, logger)
except (Error, SOSSdb.SOSSdbError), e:
logger.error(str(e))
sys.exit(1)
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('jplObjectDBSearch', options)
targetID = jplObjectDBSearch(options.targetName, options.targetID, logger)
logger.info('targetID %s' % targetID)
print 'targetID %s' % targetID
def setUp(self):
try:
pyhome = os.environ['PYHOME']
cfgDir = os.path.join(pyhome, 'cfg', 'alarm')
except:
cfgDir = '.'
default_alarm_cfg_file = os.path.join(cfgDir, '*.yml')
from optparse import OptionParser
usage = "usage: %prog [options]"
optprs = OptionParser(usage=usage, version=('%%prog'))
optprs.add_option("-f",
"--configfile",
dest="configfile",
default=default_alarm_cfg_file,
help="Specify configuration file")
ssdlog.addlogopts(optprs)
(options, args) = optprs.parse_args(sys.argv[1:])
# Create top level logger.
logger = ssdlog.make_logger('module_test', options)
dummyDatafileLock = None
try:
self.svConfig = StatusVar.StatusVarConfig(options.configfile,
dummyDatafileLock,
logger)
except Exception, e:
logger.error('Error opening configuration file(s): %s' % str(e))
def start(options):
# Create logger
logger = ssdlog.make_logger('ltcs-remote', options)
# Initialize remote objects service, necessary before any
ro.init()
svc = LTCSRemoteService(options, logger, usethread=True)
def main(options, args):
logger = ssdlog.make_logger('test', options)
ro.init()
ev_quit = threading.Event()
queue = Queue.Queue()
# make a name for our monitor
myMonName = options.name
# monitor channels we are interested in
channels = options.channels.split(',')
# Create a local monitor
mymon = Monitor.Monitor(myMonName, logger, numthreads=20)
# Make our callback functions
m = Make_cb(logger=logger,
monitor=mymon,
queue=queue,
monpath=options.monpath,
watch_execs=options.watch_execs,
history=options.history)
# Subscribe our callback functions to the local monitor
mymon.subscribe_cb(m.anon_arr, channels)
server_started = False
try:
# Startup monitor threadpool
mymon.start(wait=True)
# start_server is necessary if we are subscribing, but not if only
# publishing
mymon.start_server(wait=True, port=options.port)
server_started = True
# subscribe our monitor to the central monitor hub
mymon.subscribe_remote(options.monitor, channels, ())
while not ev_quit.isSet():
try:
(path, tree, time) = queue.get(block=True, timeout=1.0)
printTree(path, tree, time)
except Queue.Empty:
continue
except KeyboardInterrupt:
logger.error("Received keyboard interrupt!")
ev_quit.set()
finally:
if server_started:
mymon.stop_server(wait=True)
mymon.stop(wait=True)
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('resource', options)
class AppWindow(QtGui.QMainWindow):
def __init__(self):
super(AppWindow, self).__init__()
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.w = 450
self.h = 25
self.init_ui()
def init_ui(self):
self.resize(self.w, self.h)
self.main_widget = QtGui.QWidget()
l = QtGui.QVBoxLayout(self.main_widget)
l.setMargin(0)
l.setSpacing(0)
if options.mode == 'water':
r = WaterStorageDisplay(parent=self.main_widget, logger=logger)
elif options.mode == 'oil':
r = OilStorageDisplay(parent=self.main_widget, logger=logger)
else:
r = ResourceDisplay(parent=self.main_widget, logger=logger)
l.addWidget(r)
timer = QtCore.QTimer(self)
QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"), r.tick)
timer.start(options.interval)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
self.statusBar().showMessage("%s starting..." % options.mode,
options.interval)
def closeEvent(self, ce):
self.close()
try:
qApp = QtGui.QApplication(sys.argv)
aw = AppWindow()
print 'state'
#state = State(logger=logger)
aw.setWindowTitle("%s" % progname)
aw.show()
#state.show()
print 'show'
sys.exit(qApp.exec_())
except KeyboardInterrupt, e:
logger.warn('keyboard interruption....')
sys.exit(0)
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('names', options)
try:
myhost = ro.get_myhost()
except Exception, e:
raise nameServiceError("Can't get my own hostname: %s" % str(e))
def main(options, args):
logger = ssdlog.make_logger('test', options)
print "mode<%s>" % (options.mode)
if not options.mode == 'test':
ro.init()
# make a name for our monitor
#myMonName = ('testmon-%d' % os.getpid())
myMonName = ('testmon')
# monitor channels we are interested in
channels = options.channels.split(',')
# Create a local monitor
mymon = Monitor.Monitor(myMonName, logger, numthreads=4)
# Startup monitor threadpool
mymon.start(wait=True)
# start_server is necessary if we are subscribing, but not if only
# publishing
mymon.start_server(port=options.port, wait=True)
#mymon.start_server(wait=True)
# Make our callback functions
m = Make_cb(logger=logger, monitor=mymon)
# Subscribe our callback functions to the local monitor
mymon.subscribe_cb(m.anon_arr, channels)
try:
# subscribe our monitor to the central monitor hub
#monitor = ro.remoteObjectProxy(options.monitor)
mymon.subscribe_remote(options.monitor, channels, ())
except:
logger.error("subscribe to the central monitor faild")
else:
feed_test_data()
mymon = None
try:
gtk.gdk.threads_init()
task_view = TreeView(logger)
task_view.start_updating()
gtk.main()
stop_service(task_view, mymon=mymon)
print 'GUI END'
except KeyboardInterrupt:
#gtk.main_quit()
stop_service(task_view, mymon=mymon)
def main(options, args, ui):
myhost = SOSSrpc.get_myhost(short=False)
basename = 'g2disp-%s' % (myhost.replace('.', '_'))
logger = ssdlog.make_logger(basename, options)
# Make our callback object
mobj = g2Disp(logger=logger, basename=basename)
ui.ui(mobj)
def main(options, args):
logger = ssdlog.make_logger('test', options)
if options.mode == 'test':
print 'test mode'
feed_test_data()
mymon = None
else:
ro.init()
# make a name for our monitor
#myMonName = ('testmon-%d' % os.getpid())
myMonName = ('testmon')
# monitor channels we are interested in
channels = options.channels.split(',')
# Create a local monitor
mymon = Monitor.Monitor(myMonName, logger, numthreads=4)
# Startup monitor threadpool
mymon.start(wait=True)
# start_server is necessary if we are subscribing, but not if only
# publishing
mymon.start_server(wait=True)
# Make our callback functions
m = Make_cb(logger=logger, monitor=mymon)
# Subscribe our callback functions to the local monitor
mymon.subscribe_cb(m.anon_arr, channels)
try:
# subscribe our monitor to the central monitor hub
monitor = ro.remoteObjectProxy(options.monitor)
monitor.subscribe(myMonName, channels, ())
except:
logger.error("subscribe to the central monitor faild")
try:
app = QtGui.QApplication(sys.argv)
tv = TreeView()
tv.start_updating()
tv.show()
sys.exit(app.exec_())
stop_service(tv, mymon=mymon)
print 'GUI END'
except KeyboardInterrupt:
print 'Keyboard'
#gtk.main_quit()
stop_service(tv, mymon=mymon)
def main(options, args):
logname = 'agsim'
logger = ssdlog.make_logger(logname, options)
logger.info('guider sim starting ...')
app = QApplication(sys.argv)
gsim = GuiderSim(logger)
gsim.show()
app.exec_()
def main(options, args):
ro_hosts = options.gen2host.split(',')
ro.init(ro_hosts)
svcname = options.svcname
monname = svcname + '.mon'
# create a real logger if you want logging
logger = ssdlog.make_logger(svcname, options)
ev_quit = threading.Event()
# Create a local subscribe object
myhost = ro.get_myhost(short=True)
mymon = Monitor.Monitor(monname, logger)
channels = options.channels.split(',')
relay = StatusRelay(logger, options.statsvc, options.monitor,
mymon, channels)
# Startup monitor
mymon.start(wait=True)
monport = options.monport
if not monport:
monport = options.port + 1
mymon.start_server(wait=True, port=monport)
threadPool = mymon.get_threadPool()
svc = ro.remoteObjectServer(svcname=options.svcname,
obj=relay, logger=logger,
port=options.port,
default_auth=None,
ev_quit=ev_quit,
usethread=False,
threadPool=threadPool)
try:
relay.update_statusProxy()
relay.update_monitorFeed()
try:
print "Press ^C to terminate the server."
svc.ro_start(wait=True)
svr_started = True
except KeyboardInterrupt:
logger.error("Caught keyboard interrupt!")
ev_quit.set()
finally:
logger.info("Shutting down...")
mymon.unsubscribe_remote('monitor', channels, {})
mymon.stop_server()
mymon.stop()
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger(options.svcname, options)
# Initialize remote objects subsystem.
try:
ro.init()
except ro.remoteObjectError, e:
logger.error("Error initializing remote objects subsystem: %s" % str(e))
sys.exit(1)
def main(options, args):
global statusFromGen2, lock
# Create top level logger.
logger = ssdlog.make_logger('alarm_monitor', options)
# Load the status variable configuration
try:
svConfig = StatusVar.StatusVarConfig(options.configfile,
persistDatafileLock, logger)
except Exception, e:
logger.error('Error opening configuration file(s): %s' % str(e))
return
def main(options, args):
basename = options.svcname
logger = ssdlog.make_logger(basename, options)
# Initialize remoteObjects subsystem
try:
ro.init()
except ro.remoteObjectError, e:
logger.error("Error initializing remote objects subsystem: %s" % \
str(e))
sys.exit(1)
def main(options, args):
# Create top level logger.
logger = ssdlog.make_logger('mgrsvc', options)
# Get the names of the nodes in this cluster and remove our name. The
# result is the list of hosts running name servers that we need to
# synchronize with.
try:
myhost = ro.get_myhost(short=True)
except Exception, e:
raise managerSvcError("Can't get my own hostname: %s" % str(e))
def main(options, args):
''' right now, this main is for testing purpose'''
import starlist
logname = 'star_selection'
# Create top level logger.
logger = ssdlog.make_logger(logname, options)
sh_keys = {'ra': 10.1, 'dec': 10.0, 'fov': 0.076, 'limitmag': 13.0}
ag_keys = {
'ra': 10.0,
'dec': 20.0,
'fov': 0.076,
'probe_ra': 10.0,
'probe_dec': 20.0,
'focus': 'CS',
'ins': 'MOIRCS',
'probe_r': 0.0,
'probe_theta': 0.0,
'probe_x': 0.0,
'probe_y': 0.0,
'pa': 0.0,
'limitmag': 15.0,
'goodmag': 10.0,
'fov_pattern': 'STANDARD'
}
try:
catalog = starlist.CatalogSearch(logger)
starlist = catalog.search_starcatalog(ra=sh_keys['ra'],
dec=sh_keys['dec'],
fov=sh_keys['fov'],
limitmag=sh_keys['limitmag'])
ss = StarSelection(logger)
res = ss.select_sh_stars(sh_keys, starlist)
# for star in res:
# print star['name']
# starlist=catalog.search_starcatalog(ra=ag_keys['ra'], dec=ag_keys['dec'], fov=ag_keys['fov'], limitmag=ag_keys['limitmag'])
# res=ss.select_ag_stars(ag_keys, starlist)
print 'prefered=%d' % res.get('prefered_num')
for star in res.get('selected_stars'):
print star['name'], star['priority']
except KeyboardInterrupt:
print 'keyboard interrupting...'
except Exception as e:
print 'excpetion %s' % e
def main(options, args):
svcname = ('ana_menu')
if not options.logstderr:
options.logfile='/tmp/ana.log'
options.loglevel=0
logger = ssdlog.make_logger(svcname, options)
try:
os.chmod(options.logfile,0666)
except Exception,e:
logger.warn('warning: changing permission.<%s> ' %(e))
def main(options,args):
logname = 'email'
logger = ssdlog.make_logger(logname, options)
subject='TEST'
sender='*****@*****.**'
recipient='*****@*****.**'
today=datetime.datetime.today()
msg='%s\nmailing to you...' %today.strftime("%Y-%m-%d %H:%M:%S")
notify_me(sub=subject, sndr=sender, rcpt=recipient, msg=msg, logger=logger)
notify_snmp(msg, logger)
def main(options, args):
svcname = options.svcname
logger = ssdlog.make_logger(svcname, options)
monchannels = ['statint', 'logs']
# Initialize remote objects subsystem.
try:
ro.init()
except ro.remoteObjectError, e:
logger.error("Error initializing remote objects subsystem: %s" %
str(e))
sys.exit(1)