def __init__(self): self.logger = catolog.get_logger("Runtimes") # initialize the runtime array dictionary self.data = {} # for the new variable syntax feature self.obj_data = {}
def main(): # CATOPROCESS STARTUP dbglvl = 20 if "csk_ui_debug" in catoconfig.CONFIG: try: dbglvl = int(catoconfig.CONFIG["csk_ui_debug"]) except: raise Exception("csk_ui_debug setting in cato.conf must be an integer between 0-50.") catolog.DEBUG = dbglvl # this is a service, which has a db connection. # but we're not gonna use that for gui calls - we'll make our own when needed. server = catoprocess.CatoService(app_name) server.startup() # now that the service is set up, we'll know what the logfile name is. # so reget the logger logger = catolog.get_logger(app_name) catolog.set_debug(dbglvl) logger.info("Velocity UI - Version %s" % catoconfig.VERSION) logger.info("DEBUG set to %d..." % dbglvl) # WEB.PY STARTUP if "csk_ui_port" in catoconfig.CONFIG: port = catoconfig.CONFIG["csk_ui_port"] sys.argv.append(port) # enable ssl? if catocommon.is_true(catoconfig.CONFIG.get("csk_ui_use_ssl")): logger.info("Using SSL/TLS...") sslcert = catoconfig.CONFIG.get("csk_ui_ssl_cert", os.path.join(catoconfig.CONFDIR, "cato.crt")) sslkey = catoconfig.CONFIG.get("csk_ui_ssl_key", os.path.join(catoconfig.CONFDIR, "cato.key")) try: with open(sslcert): pass logger.debug("SSL Certificate [%s]" % sslcert) CherryPyWSGIServer.ssl_certificate = sslcert except: raise Exception("SSL Certificate not found at [%s]" % sslcert) try: with open(sslkey): pass logger.debug("SSL Key [%s]" % sslkey) CherryPyWSGIServer.ssl_private_key = sslkey except: raise Exception("SSL Key not found at [%s]" % sslcert) else: logger.info("Using standard HTTP. (Set csk_ui_use_ssl to 'true' in cato.conf to enable SSL/TLS.)") app.add_processor(auth_app_processor) app.notfound = notfound app.run()
def __init__(self, process_name): self.host = os.uname()[1] self.platform = os.uname()[0] self.user = pwd.getpwuid(os.getuid())[0] self.host_domain = self.user + '@' + os.uname()[1] self.my_pid = os.getpid() self.process_name = process_name self.home = catoconfig.BASEPATH self.tmpdir = catoconfig.CONFIG["tmpdir"] # tell catoconfig what the LOGFILE name is, then get a logger # if logging has already been set up this won't do anything # but if it's not yet, this will set the basic config logging.basicConfig(level=logging.DEBUG) catolog.set_logfile(os.path.join(catolog.LOGPATH, self.process_name.lower() + ".log")) self.logger = catolog.get_logger(process_name)
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import urllib2 import time import hmac import hashlib import base64 from catocloud import cloud from catocommon import catocommon from catolog import catolog logger = catolog.get_logger(__name__) # logger.info("foo") class awsInterface(object): def GetCloudObjectsAsXML(self, account_id, cloud_id, cloud_object_type, additional_args={}): try: sXML = "" ca = cloud.CloudAccount() ca.FromID(account_id) if ca.ID is None: msg = "Failed to get Cloud Account details for Cloud Account ID [" + account_id + "]." logger.error(msg) return None, msg
def _inject(templateobj): """ We need to wrap each pages html with a middle 'wrapper' before inserting it into the main base page. So, we take the already rendered html, and do a final replacement on it. """ templateobj["__body__"] = templateobj["__body__"].replace("<!--##FOOTER##-->", uiGlobals.static_content["automatefooter"]) templateobj["__body__"] = templateobj["__body__"].replace("<!--##AFTER##-->", uiGlobals.static_content["automateafter"]) return templateobj # THE MAIN STUFF logger = catolog.get_logger("csk_admin_ui") uiGlobals.urls += ( '/automate', 'cskadminuicore.cskadminuicore.home', '/automate/home', 'home', '/automate/importObject', 'importObject', '/automate/cloudEdit', 'cloudEdit', '/automate/cloudAccountEdit', 'cloudAccountEdit', '/automate/cloudDiscovery', 'cloudDiscovery', '/automate/taskEdit', 'taskEdit', '/automate/taskView', 'taskView', '/automate/taskPrint', 'taskPrint', '/automate/taskRunLog', 'taskRunLog', '/automate/taskActivityLog', 'taskActivityLog', '/automate/taskManage', 'taskManage', '/automate/systemStatus', 'systemStatus',
import sys import json import web import shelve from web.wsgiserver import CherryPyWSGIServer if "CSK_HOME" not in os.environ: raise Exception("CSK_HOME environment variable not set.") sys.path.insert(0, os.path.join(os.environ["CSK_HOME"], "cato", "lib")) sys.path.insert(0, os.path.join(os.environ["CSK_HOME"], "maestro", "lib")) sys.path.insert(0, os.path.join(os.environ["CSK_HOME"], "legato", "lib")) from catolog import catolog app_name = "csk_ui" logger = catolog.get_logger(app_name) from catoconfig import catoconfig from catocommon import catocommon, catoprocess from catolicense import catolicense from catoui import uiGlobals, uiCommon from catoerrors import InfoException, SessionError web_root = os.path.join(os.environ["CSK_HOME"], "cato", "ui", "cskui") os.chdir(web_root) """ wmHandler is the default handler for any urls not defined in the urls mapping below. (web.py required explicit url mapping) web.py will instantiate this class, and invoke either the GET or POST method.
def main(): # CATOPROCESS STARTUP dbglvl = 20 if "admin_ui_debug" in catoconfig.CONFIG: try: dbglvl = int(catoconfig.CONFIG["admin_ui_debug"]) except: raise Exception("admin_ui_debug setting in cato.conf must be an integer between 0-50.") catolog.DEBUG = dbglvl c_dbglvl = 20 if "admin_ui_client_debug" in catoconfig.CONFIG: try: c_dbglvl = int(catoconfig.CONFIG["admin_ui_client_debug"]) except: raise Exception("admin_ui_client_debug setting in cato.conf must be an integer between 0-50.") catolog.CLIENTDEBUG = c_dbglvl # this is a service, which has a db connection. # but we're not gonna use that for gui calls - we'll make our own when needed. server = catoprocess.CatoService(app_name) server.startup() # now that the service is set up, we'll know what the logfile name is. # so reget the logger logger = catolog.get_logger(app_name) catolog.set_debug(dbglvl) logger.info("Cato UI - Version %s" % catoconfig.VERSION) logger.info("DEBUG set to %d..." % dbglvl) logger.info("CLIENTDEBUG set to %d..." % c_dbglvl) # we need to build some static html here... # caching in the session is a bad idea, and this stuff very very rarely changes. # so, when the service is started it will update the files, and the ui # will simply pull in the files when requested. _build_ui_cache() # WEB.PY STARTUP if "admin_ui_port" in catoconfig.CONFIG: port = catoconfig.CONFIG["admin_ui_port"] sys.argv.append(port) # enable ssl? if catocommon.is_true(catoconfig.CONFIG.get("admin_ui_use_ssl")): logger.info("Using SSL/TLS...") sslcert = catoconfig.CONFIG.get("admin_ui_ssl_cert", os.path.join(catoconfig.CONFDIR, "cato.crt")) sslkey = catoconfig.CONFIG.get("admin_ui_ssl_key", os.path.join(catoconfig.CONFDIR, "cato.key")) try: with open(sslcert): pass logger.debug("SSL Certificate [%s]" % sslcert) CherryPyWSGIServer.ssl_certificate = sslcert except: raise Exception("SSL Certificate not found at [%s]" % sslcert) try: with open(sslkey): pass logger.debug("SSL Key [%s]" % sslkey) CherryPyWSGIServer.ssl_private_key = sslkey except: raise Exception("SSL Key not found at [%s]" % sslcert) else: logger.info("Using standard HTTP. (Set admin_ui_use_ssl to 'true' in cato.conf to enable SSL/TLS.)") app.add_processor(auth_app_processor) app.notfound = notfound app.run()
def main(): dbglvl = 20 if "rest_api_debug" in catoconfig.CONFIG: try: dbglvl = int(catoconfig.CONFIG["rest_api_debug"]) except: raise Exception("rest_api_debug setting in cato.conf must be an integer between 0-50.") catolog.DEBUG = dbglvl server = catoprocess.CatoService(app_name) server.startup() # now that the service is set up, we'll know what the logfile name is. # so reget the logger logger = catolog.get_logger(app_name) catolog.set_debug(dbglvl) if len(sys.argv) < 2: if "rest_api_port" in catoconfig.CONFIG: port = catoconfig.CONFIG["rest_api_port"] else: port = "8081" sys.argv.append(port) # enable ssl? if catocommon.is_true(catoconfig.CONFIG.get("rest_api_use_ssl")): logger.info("Using SSL/TLS...") sslcert = catoconfig.CONFIG.get("rest_api_ssl_cert", os.path.join(catoconfig.CONFDIR, "cato.crt")) sslkey = catoconfig.CONFIG.get("rest_api_ssl_key", os.path.join(catoconfig.CONFDIR, "cato.key")) try: with open(sslcert): pass logger.debug("SSL Certificate [%s]" % sslcert) CherryPyWSGIServer.ssl_certificate = sslcert except: raise Exception("SSL Certificate not found at [%s]" % sslcert) try: with open(sslkey): pass logger.debug("SSL Key [%s]" % sslkey) CherryPyWSGIServer.ssl_private_key = sslkey except: raise Exception("SSL Key not found at [%s]" % sslcert) else: logger.info("Using standard HTTP. (Set rest_api_use_ssl to 'true' in cato.conf to enable SSL/TLS.)") urls = ( '/', 'index', '/version', 'version', '/configure', 'configure', '/getlog', 'getlog', '/setdebug', 'setdebug', '/favicon.ico', 'favicon', '/(.*)', 'wmHandler' ) app = ExceptionHandlingApplication(urls, globals(), autoreload=True) # setting this to True seems to show a lot more detail in UI exceptions web.config.debug = False app.run()