def main(configFile):
from celery.bin import celeryd
from j25.scripts import Server
print Server.getBanner()
logger = logging.getLogger("j25")
logger.debug("Started with argv=%s", str(sys.argv))
if configFile:
from j25.Configuration import Configuration
config = Configuration.load_file(configFile)
else:
config = Configuration.load_defaults()
import j25
# if config.main.mode == "DEV":
# Importer.enable()
# j25._reloader = Reloader(0.6)
# j25._reloader.start()
# logger.warning("\033[1;31mDEVELOPMENT MODE ACTIVE\033[0m")
logger.info("\033[1;33mProject: %s\033[0m", config.main.project_name)
#setting configuration global
j25.config = config
#init store
logger.debug("Connecting to Database")
j25.initStore()
celeryd.main()
def newApp(args, options):
from j25.Configuration import Configuration
if len(args) < 2:
print >> sys.stderr, "you must supply the name of the app"
exit(1)
_checkProject(AUTO_PROJECT_DIRS)
appName = args[1]
appDirectory = os.path.join('apps', appName)
print Server.getBanner()
print COLOR_SEQ % 33
try:
_createPythonPackage(HERE, appDirectory, True)
f = open(os.path.join(appDirectory, 'config.py'), 'w')
f.write(app_config_template)
f.close()
f = open(os.path.join(appDirectory, 'routing.py'), 'w')
f.write(app_routing_template % appName)
f.close()
for directory, is_python_package in AUTO_APP_DIRS:
_createPythonPackage(appDirectory, directory, is_python_package)
#update configuration
config = Configuration.load_file("server.ini", False)
currentApps = eval(config.main.applications)
assert isinstance(currentApps, list)
currentApps.append('apps.%s' % appName)
config.main.applications = str(list(set(currentApps)))
Configuration.dump_file("server.ini", config)
logger.info("Application %s has been created. Current project has been configured." % appName)
finally:
print RESET_SEQ
def create_instance():
##loading the Default configuration
cfg = Configuration.create_instance()
cfg.main.services_packages = "test.sample_services, test.sample_services2"
cfg.main.model_packages = "test.dummy"
##setting the Test-Mode custom configurations
cfg.main.project_name = "Test Project"
cfg.main.ip = "127.0.0.1"
cfg.main.port = "8888"
# Cache regions
cfg.cache.regions = "mongodbCache, memcached"
# configuration for mongodb cache region
cfg.cache.mongodbCache_type = "mongodb"
cfg.cache.mongodbCache_url = ("mongodb://localhost:27017/c9CachingDB#c9CachingCollection")
cfg.cache.add_option("mongodbCache_expire", 604800)
# configuration for mongodb memcached region
cfg.cache.memcached_type = "ext:memcached"
cfg.cache.memcached_url = "127.0.0.1:9090"
cfg.cache.add_option("memcached_expire", 604800)
# Setting the memcached testing server parameters
cfg.memcached.servers = "127.0.0.1:9090"
# # Setting Test-Exchange configuration
testExchangeSection = cfg.add_section("messagebus_test_exchange")
testExchangeSection.add_option('exchange_type', 'fanout') # default exchange type
return cfg
def installApp(args, options):
from j25.Configuration import Configuration
if len(args) < 2:
print >> sys.stderr, "you must supply the name of the app"
exit(1)
_checkProject(AUTO_PROJECT_DIRS)
appName = args[1]
print Server.getBanner()
print COLOR_SEQ % 33
config = Configuration.load_file('server.ini', False)
currentApps = eval(config.main.applications)
assert isinstance(currentApps, list)
if not appName in currentApps:
currentApps.append(appName)
config.main.applications = str(currentApps)
Configuration.dump_file('server.ini', config)
logger.info("\033[1;33mApplication %s added to project.\033[0m"% appName)
else:
logger.info("\033[1;33mApplication %s already installed in the project.\033[0m" % appName)
def testDumpFile(self):
fileObj = tempfile.NamedTemporaryFile()
fileName = fileObj.name
configObj = TestConfiguration.create_instance()
Configuration.dump_file(fileName, configObj)
loadedCfg = Configuration.load_file(fileName)
# comparing cfg and configObj
self.assertEquals(sorted(loadedCfg.sections()), sorted(configObj.sections()))
configObjDict = {}
ConfigFileDict = {}
configObjOptions = []
ConfigFileOptions = []
for section in configObj.sections():
secObj = configObj.get_section(section)
configObjOptions.extend(secObj.options())
tempOptionsDict = {}
for option in secObj.options():
tempOptionsDict[option] = secObj.get_option(option)
configObjDict[section] = tempOptionsDict
for section in loadedCfg.sections():
secObj = configObj.get_section(section)
ConfigFileOptions.extend(secObj.options())
tempOptionsDict = {}
for option in secObj.options():
tempOptionsDict[option] = secObj.get_option(option)
ConfigFileDict[section] = tempOptionsDict
self.assertTrue(configObjOptions)
self.assertTrue(ConfigFileOptions)
self.assertTrue(ConfigFileDict)
self.assertTrue(configObjDict)
self.assertEquals(sorted(configObjOptions), sorted(ConfigFileOptions))
self.assertEquals(len(ConfigFileDict), len(configObjDict))
for k, v in configObjDict.iteritems():
self.assertEquals(v, ConfigFileDict[k])
for k, v in ConfigFileDict.iteritems():
self.assertEquals(v, configObjDict[k])
def testDefaults(self):
config = Configuration.load_defaults()
self.assertTrue(hasattr(config, "main"))
self.assertEquals("0.0.0.0", config.main.ip)
self.assertEquals(8800, int(config.main.port))
self.assertEquals(10, int(config.main.num_threads))
self.assertTrue(hasattr(config, "memcached"))
self.assertEquals("127.0.0.1:11211", config.memcached.servers)
self.assertEquals(0, config.memcached.expireTime)
self.assertEquals(0, config.memcached.min_compress_len)
def read_configuration(self):
configName = os.environ.setdefault("WORKER_CONFIG", "workerconfig")
try:
logging.info("loading configuration from %s", configName)
configModule = __import__(configName, fromlist="t")
except ImportError:
logging.info("Couldn't access configuration %s", configName)
sys.exit(1)
config = Configuration.load_file("server.ini")
j25.config = config
self.configured = True
return DictAttribute(configModule)
def boot(configFile):
logger = logging.getLogger("j25")
logger.debug("Started with argv=%s", str(sys.argv))
if configFile:
from j25.Configuration import Configuration
config = Configuration.load_file(configFile)
else:
config = Configuration.load_defaults()
import j25
if config.main.mode == "DEV":
Importer.enable()
j25._reloader = Reloader(0.6)
j25._reloader.start()
logger.warning("\033[1;31mDEVELOPMENT MODE ACTIVE\033[0m")
from j25.http.HttpServer import HttpServer
from j25.http.RequestDispatcher import RequestDispatcher
from j25.loaders import AppLoader
logger.info("\033[1;33mProject: %s\033[0m", config.main.project_name)
#setting configuration global
j25.config = config
#init store
logger.debug("Connecting to Database")
j25.initStore()
#create the dispatcher
j25._dispatcher = RequestDispatcher(AppLoader.AutoAppLoader(eval(config.main.applications)))
j25._create_routing_middleware()
j25._dispatcher.load_applications()
#run the server and loop forever
ws = HttpServer(config)
logger.info(getBanner())
ws.start()
def newProject(args, options):
from j25.Configuration import Configuration
if len(args) < 2:
print >> sys.stderr, "Please supply a project name"
exit(1)
appName = options.withapp
projectName = args[1]
print Server.getBanner()
print COLOR_SEQ % 33
print "Creating project: %s" % projectName
_createPythonPackage(HERE, projectName, False)
#creating project structure
for directory, is_python_package in AUTO_PROJECT_DIRS:
_createPythonPackage(projectName, directory, is_python_package)
#creating templates
config = Configuration.create_empty_config()
s1 = config.add_section('main')
s1.add_option('project_name', projectName)
s1.add_option('applications', [])
s1.add_option('excluded_applications_from_worker', [])
s1.add_option("mode", "DEV")
s1.add_option("ip", "0.0.0.0")
s1.add_option("port", "8800")
s1.add_option("is_subdomain_aware", True)
s2 = config.add_section('session')
s1.add_option('project_name', projectName)
s2.add_option('secret', uuid4().hex + uuid4().hex)
s2.add_option('url', ('%s/c9#session' % Constants.MONGODB_URL))
s2.add_option('secure', 'False')
s2.add_option('timeout', '600')
s3 = config.add_section('store')
s3.add_option("db_name", "c9_%s" % projectName)
s3.add_option("ip", "127.0.0.1")
s3.add_option("auto_create_collections", None)
Configuration.dump_file(os.path.join(projectName, 'server.ini'), config)
f = open(os.path.join(projectName, 'routing.py'), 'w')
f.write(project_routing_template)
f.close()
f = open(os.path.join(projectName, 'workerconfig.py'), 'w')
f.write(app_workerconfig)
f.close()
if options.withapp:
config = Configuration.load_file(os.path.join(projectName, 'server.ini'), False)
builtin_Apps = eval(config.main.applications)
assert isinstance(builtin_Apps, list)
if not appName in builtin_Apps:
builtin_Apps.append(appName)
config.main.applications = str(builtin_Apps)
Configuration.dump_file(os.path.join(projectName, 'server.ini'), config)
logger.info("\033[1;33mProject %s Created with Application %s.\033[0m"% (projectName, appName))
else:
logger.info("\033[1;33mApplication %s already installed in the project by Default.\033[0m" % appName)
print RESET_SEQ
def testDefaultsOverlaying(self):
config = Configuration.load_file(self.f.name)
self.assertTrue(hasattr(config, "main"))
self.assertEquals("127.0.0.1", config.main.ip)
self.assertEquals(8888, int(config.main.port))
self.assertEquals(10, int(config.main.num_threads))
def testLoadingFromFile(self):
config = Configuration.load_file(self.f.name)
self._testLoading(config)
def testLoadingFromFileObj(self):
fileObj = open(self.f.name)
config = Configuration.load_from_file_obj(fileObj)
self._testLoading(config)
def dumpConfig(args, options):
from j25.Configuration import Configuration
if len(args) < 2:
print >> sys.stderr, "Please supply a configuration filename"
exit(1)
Configuration.dump_file(args[1])
