|
|
@@ -1,873 +0,0 @@
|
|
|
-#!/usr/bin/env python2
|
|
|
-
|
|
|
-# Copyright (C) 2012-2014, Eduardo Silva <[email protected]>
|
|
|
-#
|
|
|
-# This program is free software; you can redistribute it and/or modify
|
|
|
-# it under the terms of the GNU General Public License as published by
|
|
|
-# the Free Software Foundation; either version 2 of the License, or
|
|
|
-# (at your option) any later version.
|
|
|
-#
|
|
|
-# This program is distributed in the hope that it will be useful,
|
|
|
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
-# GNU General Public License for more details.
|
|
|
-#
|
|
|
-# You should have received a copy of the GNU General Public License
|
|
|
-# along with this program; if not, write to the Free Software
|
|
|
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
-
|
|
|
-import os
|
|
|
-import sys
|
|
|
-import shutil
|
|
|
-import getopt
|
|
|
-import datetime
|
|
|
-import ConfigParser
|
|
|
-
|
|
|
-from git import GitProject
|
|
|
-from utils import *
|
|
|
-
|
|
|
-# Version
|
|
|
-DUDAC_VERSION = "0.23"
|
|
|
-
|
|
|
-# Internal / Protocol
|
|
|
-PROTOCOL_HTTPS = 0
|
|
|
-PROTOCOL_GIT = 1
|
|
|
-
|
|
|
-class DudaConfig(ConfigParser.ConfigParser):
|
|
|
- def __init__(self):
|
|
|
- ConfigParser.ConfigParser.__init__(self)
|
|
|
-
|
|
|
- def open(self, path):
|
|
|
- self.read(path)
|
|
|
-
|
|
|
- def get_handlers(self):
|
|
|
- return self.sections()
|
|
|
-
|
|
|
- def get_key(self, handler, key):
|
|
|
- try:
|
|
|
- val = self.get(handler, key)
|
|
|
- return val
|
|
|
- except:
|
|
|
- return None
|
|
|
-
|
|
|
-class Monkey:
|
|
|
- opts = ''
|
|
|
- recent_configure = False
|
|
|
- recent_build = False
|
|
|
- recent_clean = False
|
|
|
-
|
|
|
- def __init__(self, source_path):
|
|
|
- self.mk_path = source_path
|
|
|
- self.SSL = False
|
|
|
-
|
|
|
- def configure(self):
|
|
|
- if self.recent_configure is True:
|
|
|
- return
|
|
|
-
|
|
|
- cpath = os.getcwd()
|
|
|
- os.chdir(self.mk_path)
|
|
|
-
|
|
|
- configure = "./configure --debug --disable-plugins='*' --enable-plugins='liana,duda' " + self.opts
|
|
|
-
|
|
|
- # If we have SSL enable, we have to replace the transport layer, that means
|
|
|
- # disable Liana and enable the new PolarSSL, later we need to generate
|
|
|
- # certificates and configure everything to make it work properly
|
|
|
- if self.SSL is True:
|
|
|
- configure = configure.replace('liana','polarssl')
|
|
|
-
|
|
|
- # Run the configure script
|
|
|
- execute("Monkey : prepare build", configure)
|
|
|
-
|
|
|
- # Revert to original path
|
|
|
- os.chdir(cpath)
|
|
|
- self.recent_configure = True
|
|
|
-
|
|
|
- def make_build(self):
|
|
|
- if self.recent_build is True:
|
|
|
- return
|
|
|
-
|
|
|
- cmd = "make -C %s" % (self.mk_path)
|
|
|
- execute("Monkey : building", cmd)
|
|
|
-
|
|
|
- self.recent_build = True
|
|
|
-
|
|
|
- def make_clean(self):
|
|
|
- if self.recent_clean is True:
|
|
|
- return
|
|
|
-
|
|
|
- if os.path.exists(self.mk_path + '/Makefile') is False:
|
|
|
- return
|
|
|
-
|
|
|
- cmd = "make -C %s clean" % (self.mk_path)
|
|
|
- execute("Monkey : cleaning", cmd)
|
|
|
-
|
|
|
- self.recent_clean = True
|
|
|
-
|
|
|
- def system(self, cmd):
|
|
|
- return commands.getstatusoutput(cmd)
|
|
|
-
|
|
|
- def update_transport_layer(self, t='plain'):
|
|
|
- if t == 'plain':
|
|
|
- pass
|
|
|
- elif t == 'SSL':
|
|
|
- pass
|
|
|
-
|
|
|
-class MonkeyGIT (GitProject):
|
|
|
- def __init__(self):
|
|
|
- https_repo = 'https://github.com/monkey/monkey.git'
|
|
|
- git_repo = '[email protected]:monkey/monkey.git'
|
|
|
- GitProject.__init__(self, 'Monkey', https_repo, git_repo)
|
|
|
-
|
|
|
- def home(self):
|
|
|
- # Check our user temporal directory
|
|
|
- home = os.getenv('USERPROFILE') or os.getenv('HOME')
|
|
|
- dudac_home = "%s/.dudac" % (home)
|
|
|
-
|
|
|
- return "%s/monkey" % (dudac_home)
|
|
|
-
|
|
|
-class DudaGIT(GitProject):
|
|
|
- def __init__(self):
|
|
|
- https_repo = 'https://github.com/monkey/duda.git'
|
|
|
- git_repo = '[email protected]:monkey/duda.git'
|
|
|
- GitProject.__init__(self, 'Duda', https_repo, git_repo)
|
|
|
-
|
|
|
- def home(self):
|
|
|
- # Check our user temporal directory
|
|
|
- home = os.getenv('USERPROFILE') or os.getenv('HOME')
|
|
|
- dudac_home = "%s/.dudac" % (home)
|
|
|
-
|
|
|
- return "%s/duda" % (dudac_home)
|
|
|
-
|
|
|
-class Duda:
|
|
|
- # Default configuration directives for Monkey configuration
|
|
|
- # file located under the [SERVER] section
|
|
|
- MCONF_KNOWN = ['Port',
|
|
|
- 'Listen',
|
|
|
- 'Workers',
|
|
|
- 'Timeout',
|
|
|
- 'PidFile',
|
|
|
- 'UserDir',
|
|
|
- 'Indexfile',
|
|
|
- 'HideVersion',
|
|
|
- 'Resume',
|
|
|
- 'User',
|
|
|
- 'KeepAlive',
|
|
|
- 'KeepAliveTimeout',
|
|
|
- 'MaxKeepAliveRequest',
|
|
|
- 'MaxRequestSize',
|
|
|
- 'SymLink',
|
|
|
- 'TransportLayer',
|
|
|
- 'DefaultMimeType']
|
|
|
-
|
|
|
- def __init__(self):
|
|
|
- self.print_version()
|
|
|
- self.web_service = None
|
|
|
- self.service = None
|
|
|
- self.port = 2001
|
|
|
- self.SSL = False
|
|
|
- self.SSL_default = False
|
|
|
- self.output_stdout = False
|
|
|
- self.api_level = DEFAULT_API_LEVEL
|
|
|
- self.linux_malloc = False
|
|
|
- self.linux_trace = False
|
|
|
- self.jemalloc_stats = False
|
|
|
- self.jemalloc_prof = False
|
|
|
- self.rebuild_monkey = False
|
|
|
- self.mk_git = MonkeyGIT()
|
|
|
- self.duda_git = DudaGIT()
|
|
|
- self.mk_home = self.mk_git.home()
|
|
|
- self.duda_home = self.duda_git.home()
|
|
|
- self.dudac_wd = '%s/.dudac' % (os.getenv('USERPROFILE') or os.getenv('HOME'))
|
|
|
- self.dudac_stage_path = os.getenv('DUDAC_STAGE_PATH')
|
|
|
- self.load_makefile()
|
|
|
-
|
|
|
- # In case the DUDAC_STAGE_PATH environment variable is set, use
|
|
|
- # the alternative stage path. This is useful when using a fixed-path
|
|
|
- # version of Monkey and Duda plugin, mostly for development purposes
|
|
|
- if self.dudac_stage_path is not None:
|
|
|
- self.stage_home = self.dudac_stage_path
|
|
|
- else:
|
|
|
- self.stage_home = self.dudac_wd + '/stage/'
|
|
|
-
|
|
|
- self.monkey = Monkey(self.stage_home + 'monkey/')
|
|
|
- self.get_arguments()
|
|
|
-
|
|
|
- exit(0)
|
|
|
-
|
|
|
- def load_makefile(self):
|
|
|
- dot = os.path.dirname(os.path.abspath(__file__))
|
|
|
- f = open(os.path.join(dot, "dudac.Make"), "r")
|
|
|
- self.dudac_makefile = f.read()
|
|
|
- f.close
|
|
|
-
|
|
|
- # This routine read the config.dudac configuration file which is
|
|
|
- # optional inside every web service source code. It specifies the
|
|
|
- # Monkey sources requirements and perform the right setup
|
|
|
- def config_requirements(self):
|
|
|
- ws = os.path.abspath(self.service)
|
|
|
- if not os.path.isdir(ws):
|
|
|
- print "Error: Invalid web service directory"
|
|
|
- exit(1)
|
|
|
-
|
|
|
- # Check if is an API level
|
|
|
- try:
|
|
|
- api_number = int(self.api_level)
|
|
|
- except:
|
|
|
- api_number = -1
|
|
|
-
|
|
|
- if api_number > 0:
|
|
|
- version = "dst-%i" % (api_number)
|
|
|
- else:
|
|
|
- version = self.api_level
|
|
|
-
|
|
|
- mk_version = version
|
|
|
- mk_https_repo = None
|
|
|
- mk_git_repo = None
|
|
|
- duda_version = version
|
|
|
- duda_https_repo = None
|
|
|
- duda_git_repo = None
|
|
|
-
|
|
|
- # Check if the service have a configuration file
|
|
|
- config_file = os.path.abspath("%s/dudac.conf" % (ws))
|
|
|
- if os.path.isfile(config_file) is True:
|
|
|
- # Read the configuration
|
|
|
- config = DudaConfig()
|
|
|
- config.open(config_file)
|
|
|
-
|
|
|
- for h in config.get_handlers():
|
|
|
- if h == 'MONKEY':
|
|
|
- # Get key/values
|
|
|
- mk_version = config.get_key(h, 'version')
|
|
|
- mk_https_repo = config.get_key(h, 'https_repo')
|
|
|
- mk_git_repo = config.get_key(h, 'git_repo')
|
|
|
- elif h == 'DUDA':
|
|
|
- duda_version = config.get_key(h, 'version')
|
|
|
- duda_https_repo = config.get_key(h, 'https_repo')
|
|
|
- duda_git_repo = config.get_key(h, 'git_repo')
|
|
|
-
|
|
|
- # Configure repos
|
|
|
- self.mk_git.setup(mk_version, mk_https_repo, mk_git_repo)
|
|
|
- self.duda_git.setup(duda_version, duda_https_repo, duda_git_repo)
|
|
|
-
|
|
|
- def update_framework(self, protocol):
|
|
|
- self.mk_git.set_protocol(protocol)
|
|
|
- self.duda_git.set_protocol(protocol)
|
|
|
-
|
|
|
- if os.path.exists(self.mk_home):
|
|
|
- self.mk_git.update(self.mk_home)
|
|
|
- else:
|
|
|
- self.mk_git.clone(self.mk_home)
|
|
|
-
|
|
|
- if os.path.exists(self.duda_home):
|
|
|
- self.duda_git.update(self.duda_home)
|
|
|
- else:
|
|
|
- self.duda_git.clone(self.duda_home)
|
|
|
-
|
|
|
- # Cleanup and rebuild Monkey
|
|
|
- cpath = os.getcwd()
|
|
|
- os.chdir(self.mk_home)
|
|
|
-
|
|
|
- self.mk_git.version = self.api_level
|
|
|
- self.mk_git.snapshot()
|
|
|
-
|
|
|
- self.duda_git.version = self.api_level
|
|
|
- self.duda_git.snapshot()
|
|
|
-
|
|
|
- self.merge_on_stage()
|
|
|
- self.monkey.configure()
|
|
|
-
|
|
|
- if os.path.exists("./Makefile"):
|
|
|
- self.monkey.make_clean()
|
|
|
-
|
|
|
- self.monkey.make_build()
|
|
|
- os.chdir(cpath)
|
|
|
-
|
|
|
- def merge_on_stage(self):
|
|
|
- # Create archives from repos
|
|
|
- self.mk_git.archive_to(self.stage_home + '/monkey')
|
|
|
- self.duda_git.archive_to(self.stage_home + '/monkey/plugins/duda')
|
|
|
-
|
|
|
- # Tag the content with branch used
|
|
|
- f = open(self.stage_home + '/monkey/api_level.dudac', 'w')
|
|
|
- f.write(self.mk_git.version + '\n')
|
|
|
- f.close()
|
|
|
-
|
|
|
-
|
|
|
- def run_webservice(self, schema=None):
|
|
|
- ws = os.path.abspath(self.service)
|
|
|
- monkey_stage = self.monkey.mk_path
|
|
|
-
|
|
|
- # Check if the web service was staged and built previously, we
|
|
|
- # this check to make sure the service is updated as the user needs/want
|
|
|
- stage_level = self.stage_home + '/monkey/api_level.dudac'
|
|
|
- if os.path.isfile(stage_level):
|
|
|
- f = open(stage_level, 'r')
|
|
|
- level = f.read().replace('\n', '')
|
|
|
- f.close()
|
|
|
-
|
|
|
- if level != self.mk_git.version:
|
|
|
- self.rebuild_monkey = True
|
|
|
- else:
|
|
|
- self.rebuild_monkey = True
|
|
|
-
|
|
|
- if self.rebuild_monkey is True:
|
|
|
- # Backup our original path
|
|
|
- cpath = os.getcwd()
|
|
|
-
|
|
|
- # On rebuild, check that stack sources are in place
|
|
|
- if os.path.exists(self.mk_home) is False or \
|
|
|
- os.path.exists(self.duda_home) is False:
|
|
|
- fail_msg("Error: the stack components are missing, try: \n\n" \
|
|
|
- " $ dudac -s\n")
|
|
|
- sys.exit(1)
|
|
|
-
|
|
|
- # Make sure Monkey sources match the snapshot
|
|
|
- if not os.getenv('DUDAC_STAGE_PATH'):
|
|
|
- self.mk_git.snapshot()
|
|
|
- self.duda_git.snapshot()
|
|
|
- self.merge_on_stage()
|
|
|
-
|
|
|
- # Cleanup and rebuild Monkey
|
|
|
- os.chdir(monkey_stage)
|
|
|
-
|
|
|
- if os.path.exists("./Makefile"):
|
|
|
- self.monkey.make_clean()
|
|
|
-
|
|
|
- self.monkey.configure()
|
|
|
- self.monkey.make_build()
|
|
|
-
|
|
|
- # Restore path
|
|
|
- os.chdir(cpath)
|
|
|
-
|
|
|
- makefile = "%s/Makefile" % (ws)
|
|
|
- makefile_in = "%s/Makefile.in" % (ws)
|
|
|
- if os.path.isdir(ws) is False or os.path.exists(makefile_in) is False:
|
|
|
- print "Error: Invalid web service directory " + ws
|
|
|
- exit(1)
|
|
|
-
|
|
|
- # Monkey headers
|
|
|
- mk_inc = monkey_stage + "/src/include"
|
|
|
- mk_duda = monkey_stage + "/plugins/duda/src"
|
|
|
- mk_packages = monkey_stage + "/plugins/duda/"
|
|
|
-
|
|
|
- # Read the Makefile.in file
|
|
|
- mk_ins = []
|
|
|
- for root, dirs, files in os.walk(ws):
|
|
|
- for file in files:
|
|
|
- if file == 'Makefile.in':
|
|
|
- path = "%s/%s" % (root, file)
|
|
|
- mk_ins.append(root)
|
|
|
-
|
|
|
- for mk in mk_ins:
|
|
|
- mk_in = "%s/Makefile.in" % (mk)
|
|
|
-
|
|
|
- CC_SET = None
|
|
|
-
|
|
|
- f = open(mk_in, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- raw = ""
|
|
|
- for line in lines:
|
|
|
- if line.startswith("INCDIR"):
|
|
|
- prev = line.replace("INCDIR", "")
|
|
|
- prev = prev.replace("=", "").strip()
|
|
|
-
|
|
|
- raw += "INCDIR = " + prev
|
|
|
- raw += " -I" + mk_inc
|
|
|
- raw += " -I" + mk_duda
|
|
|
- raw += " -I" + mk_packages + "\n"
|
|
|
- else:
|
|
|
- raw += line
|
|
|
- raw += "\n"
|
|
|
-
|
|
|
- makefile = "%s/Makefile" % (mk)
|
|
|
- f_mk = open(makefile, "w")
|
|
|
- f_mk.write("# Autogenerated by Duda Client Manager\n")
|
|
|
- f_mk.write("# ====================================\n")
|
|
|
-
|
|
|
- today = datetime.datetime.now()
|
|
|
- f_mk.write("# Date : " + today.strftime('%a %d, %b %Y at %H:%M') + "\n")
|
|
|
- f_mk.write("# Stage Path: " + monkey_stage + "\n\n")
|
|
|
-
|
|
|
- f_mk.write(raw)
|
|
|
- f_mk.write(self.dudac_makefile)
|
|
|
- f_mk.close()
|
|
|
-
|
|
|
- # Cleanup web service and rebuild
|
|
|
- execute("WebService : clean", "make -C " + ws + " clean")
|
|
|
- execute("WebService : build", "make -C " + ws)
|
|
|
-
|
|
|
- # Get services
|
|
|
- services = []
|
|
|
- list = os.listdir(ws)
|
|
|
- for entry in list:
|
|
|
- p = ws + "/" + entry
|
|
|
- if os.path.isfile(p) and entry.endswith(".duda"):
|
|
|
- e = {'name': entry[:-5], 'filename': entry}
|
|
|
- services.append(e)
|
|
|
-
|
|
|
- # check that services exists
|
|
|
- if len(services) == 0:
|
|
|
- print "Error: i could not find Duda services under", ws
|
|
|
- exit(1)
|
|
|
-
|
|
|
- # Setting up virtual host
|
|
|
- vhost = monkey_stage + "/conf/sites/default"
|
|
|
- f = open(vhost, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- # Setting up web services
|
|
|
- print "%s %-70s" % (MSG_NEW, "Monkey : configure HTTP Server"),
|
|
|
- raw = ""
|
|
|
- for line in lines:
|
|
|
- if line.startswith('[WEB_'):
|
|
|
- break
|
|
|
- else:
|
|
|
- raw += line
|
|
|
-
|
|
|
- for s in services:
|
|
|
- raw += "[WEB_SERVICE]\n"
|
|
|
- raw += " Name " + s['name'] + "\n"
|
|
|
- raw += " Enabled on\n"
|
|
|
-
|
|
|
- html = os.path.abspath(self.service) + '/html/'
|
|
|
- if os.path.exists(html):
|
|
|
- raw += " DocumentRoot %s\n" % (html)
|
|
|
-
|
|
|
- confdir = os.path.abspath(self.service) + '/conf/'
|
|
|
- if os.path.exists(confdir):
|
|
|
- raw += " ConfDir %s\n" % (confdir)
|
|
|
-
|
|
|
- datadir = os.path.abspath(self.service) + '/data/'
|
|
|
- if os.path.exists(datadir):
|
|
|
- raw += " DataDir %s\n" % (datadir)
|
|
|
-
|
|
|
- logdir = os.path.abspath(self.service) + '/logs/'
|
|
|
- if os.path.exists(logdir):
|
|
|
- raw += " LogDir %s\n" % (logdir)
|
|
|
-
|
|
|
- raw += "\n"
|
|
|
-
|
|
|
- f = open(vhost, "w")
|
|
|
- f.write(raw)
|
|
|
- f.close()
|
|
|
-
|
|
|
- # Make sure Duda plugin is enabled on plugins.load
|
|
|
- plugins = monkey_stage + "/conf/plugins.load"
|
|
|
- f = open(plugins, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- raw = ""
|
|
|
- for line in lines:
|
|
|
- if line.startswith(" # Load") and line.strip().endswith("-duda.so"):
|
|
|
- line = " " + line[6:]
|
|
|
-
|
|
|
- raw += line
|
|
|
-
|
|
|
- f = open(plugins, "w")
|
|
|
- f.write(raw)
|
|
|
- f.close()
|
|
|
-
|
|
|
- # Setting up Duda plugin configuration
|
|
|
- duda = monkey_stage + "/conf/plugins/duda/duda.conf"
|
|
|
- f = open(duda, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- raw = ""
|
|
|
- for line in lines:
|
|
|
- if line.startswith(" ServicesRoot"):
|
|
|
- raw += " ServicesRoot " + ws + "\n"
|
|
|
- else:
|
|
|
- raw += line
|
|
|
-
|
|
|
- f = open(duda, "w")
|
|
|
- f.write(raw)
|
|
|
- f.close()
|
|
|
-
|
|
|
- # Setting up Monkey
|
|
|
- monkey = monkey_stage + "/conf/monkey.conf"
|
|
|
- f = open(monkey, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- raw = ""
|
|
|
- for line in lines:
|
|
|
- if line.startswith(" Port"):
|
|
|
- raw += " Port " + str(self.port) + "\n"
|
|
|
- elif line.startswith(" User"):
|
|
|
- raw += " # User Inactivated by DudaC\n"
|
|
|
- elif line.startswith(" TransportLayer") and self.rebuild_monkey is True:
|
|
|
- if self.SSL is True:
|
|
|
- raw += " TransportLayer polarssl\n"
|
|
|
- self.SSL_default = True
|
|
|
- else:
|
|
|
- raw += " TransportLayer liana\n"
|
|
|
- self.SSL_default = False
|
|
|
- elif line.startswith(" TransportLayer") and line.find('polarssl') > 0:
|
|
|
- self.SSL_default = True
|
|
|
- raw += line
|
|
|
- else:
|
|
|
- raw += line
|
|
|
-
|
|
|
- f = open(monkey, "w")
|
|
|
- f.write(raw)
|
|
|
- f.close()
|
|
|
-
|
|
|
- print MSG_OK
|
|
|
-
|
|
|
- # Schema
|
|
|
- # ======
|
|
|
- # Once the new monkey.conf Port and TransportLayer are set, we can start
|
|
|
- # overriding the config if we have a schema. We do this at the end to do not
|
|
|
- # mess with specific settings handled by the previous lines.
|
|
|
- if schema is not None:
|
|
|
- # Change direct Port global
|
|
|
- if 'Port' in schema:
|
|
|
- self.port = schema['Port']
|
|
|
-
|
|
|
- # open the file and read it content
|
|
|
- f = open(monkey, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- # compose a new buffer
|
|
|
- raw = ""
|
|
|
- for line in lines:
|
|
|
- row = line
|
|
|
- key = None
|
|
|
- val = None
|
|
|
- kv = []
|
|
|
- if line.startswith(" "):
|
|
|
- # strip the indentation
|
|
|
- row = line[4:]
|
|
|
-
|
|
|
- # Lets see if this line can belong to a commented key/value
|
|
|
- if row[:2] == '# ':
|
|
|
- arr = row[2:].split()
|
|
|
- if len(arr) == 2 and arr[0][-1] != ':':
|
|
|
- if arr[0] in self.MCONF_KNOWN:
|
|
|
- # ok, its a known key and is commented, now lets check
|
|
|
- # if this key is bein overriden through the schema
|
|
|
- if not arr[0] in schema:
|
|
|
- raw += line
|
|
|
- else:
|
|
|
- raw += " %s %s\n" % (arr[0], schema[arr[0]])
|
|
|
-
|
|
|
- continue
|
|
|
-
|
|
|
- kv = row.split()
|
|
|
- if len(kv) != 2:
|
|
|
- raw += line
|
|
|
- continue
|
|
|
- else:
|
|
|
- # Start replacing
|
|
|
- key = kv[0]
|
|
|
- val = kv[1]
|
|
|
- if key in schema:
|
|
|
- raw += " %s %s\n" % (key, schema[key])
|
|
|
- continue
|
|
|
-
|
|
|
-
|
|
|
- raw += line
|
|
|
-
|
|
|
- # Flush our new content
|
|
|
- f = open(monkey, "w")
|
|
|
- f.write(raw)
|
|
|
- f.close()
|
|
|
-
|
|
|
- # Configure Transport Layer for SSL
|
|
|
- if self.SSL_default is True:
|
|
|
- self.SSL_configure(monkey_stage)
|
|
|
-
|
|
|
- http = monkey_stage + "bin/monkey"
|
|
|
-
|
|
|
- try:
|
|
|
- if self.SSL_default is True:
|
|
|
- prot = "https"
|
|
|
- else:
|
|
|
- prot = "http"
|
|
|
-
|
|
|
- d = 0
|
|
|
- domain = prot + "://localhost:%s/" % str(self.port)
|
|
|
- schema = ""
|
|
|
- for s in services:
|
|
|
- if d > 0:
|
|
|
- schema += " "
|
|
|
- schema += domain + services[d]['name'] + '/' + "\n"
|
|
|
- d += 1
|
|
|
-
|
|
|
- # Do not trap the output of the server, just print everything
|
|
|
- # to STDOUT
|
|
|
- sc = ANSI_RESET + ANSI_CYAN + schema + ANSI_RESET
|
|
|
- if self.output_stdout is True:
|
|
|
- execute_stdout("%s Service Up : %s" \
|
|
|
- % (MSG_NEW, sc), http, False)
|
|
|
- else:
|
|
|
- execute("%s Service Up : %s" \
|
|
|
- % (MSG_NEW, sc), \
|
|
|
- http, False, True, False)
|
|
|
-
|
|
|
- except (RuntimeError, TypeError, NameError):
|
|
|
- print "\nDone!"
|
|
|
- raise
|
|
|
-
|
|
|
- def SSL_configure(self, monkey_stage):
|
|
|
- plgs = monkey_stage + "/conf/plugins.load"
|
|
|
- f = open(plgs, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- raw = ""
|
|
|
- for line in lines:
|
|
|
- if line.find('monkey-polarssl') > 0 and self.SSL is True:
|
|
|
- raw += line.replace("# Load", "Load")
|
|
|
- else:
|
|
|
- raw += line
|
|
|
-
|
|
|
- f = open(plgs, "w")
|
|
|
- f.write(raw)
|
|
|
- f.close()
|
|
|
-
|
|
|
- # Check if SSL certificates exists
|
|
|
- sslconf = monkey_stage + "/conf/plugins/polarssl/polarssl.conf"
|
|
|
- f = open(sslconf, "r")
|
|
|
- lines = f.readlines()
|
|
|
- f.close()
|
|
|
-
|
|
|
- certificate_file = None
|
|
|
- rsa_key_file = None
|
|
|
- dh_param_file = None
|
|
|
- for line in lines:
|
|
|
- row = line.strip()
|
|
|
- if row.startswith('CertificateFile'):
|
|
|
- key, val = row.split()
|
|
|
- if os.path.exists(val):
|
|
|
- certificate_file = val
|
|
|
- elif row.startswith('RSAKeyFile'):
|
|
|
- key, val = row.split()
|
|
|
- if os.path.exists(val):
|
|
|
- rsa_key_file = val
|
|
|
- elif row.startswith('DHParameterFile'):
|
|
|
- key, val = row.split()
|
|
|
- if os.path.exists(val):
|
|
|
- dh_param_file = val
|
|
|
-
|
|
|
- # Generate Certificates if they dont exists
|
|
|
- p = monkey_stage + "/conf/plugins/polarssl/"
|
|
|
- if rsa_key_file is None:
|
|
|
- cmd = "openssl genrsa -out " + p + "rsa_key.pem 1024"
|
|
|
- execute("SSL: Generate RSA", cmd)
|
|
|
- rsa_key_file = p + "rsa_key.pem"
|
|
|
- else:
|
|
|
- print_msg("SSL: RSA (cached)", True)
|
|
|
-
|
|
|
- if certificate_file is None:
|
|
|
- cmd = "openssl req -new -x509 -key " + rsa_key_file + \
|
|
|
- " -out " + p + "srv_cert.pem" + " -days 1095 -subj '/C=US'"
|
|
|
- execute("SSL: Generate Certificate", cmd)
|
|
|
- certificate_file = p + "srv_cert.pem"
|
|
|
- else:
|
|
|
- print_msg("SSL: Cert (cached)", True)
|
|
|
-
|
|
|
- if dh_param_file is None:
|
|
|
- cmd = "openssl dhparam -out " + p + "dhparam.pem 1024"
|
|
|
- execute("SSL: Generate DH Params", cmd)
|
|
|
- dh_param_file = p + "dhparam.pem"
|
|
|
- else:
|
|
|
- print_msg("SSL: DH Params (cached)", True)
|
|
|
-
|
|
|
- # Create new config and override polarssl.conf file
|
|
|
- raw = "[SSL]\n"
|
|
|
- raw += " CertificateFile " + certificate_file + "\n"
|
|
|
- raw += " RSAKeyFile " + rsa_key_file + "\n"
|
|
|
- raw += " DHParameterFile " + dh_param_file + "\n\n"
|
|
|
-
|
|
|
- f = open(sslconf, "w")
|
|
|
- f.write(raw)
|
|
|
- f.close()
|
|
|
-
|
|
|
- def reset(self):
|
|
|
- if self.dudac_stage_path is None:
|
|
|
- self.mk_git.remove(self.mk_home)
|
|
|
- self.duda_git.remove(self.duda_home)
|
|
|
-
|
|
|
- def print_version(self):
|
|
|
- print_bold("Duda Client Manager - v%s" % DUDAC_VERSION)
|
|
|
- print_color("http://duda.io", ANSI_YELLOW, True)
|
|
|
- print_color("http://monkey-project.com\n", ANSI_YELLOW, True)
|
|
|
-
|
|
|
- def print_help(self):
|
|
|
- print "Usage: dudac [-g|-s] [-V] [-S] [-h] [-v] [-A] [-J] [-T] -w WEB_SERVICE_PATH\n"
|
|
|
- print ANSI_BOLD + ANSI_WHITE + "Stack Build Options" + ANSI_RESET
|
|
|
- print " -V\t\t\tAPI level (default: %i)" % DEFAULT_API_LEVEL
|
|
|
- print " -s\t\t\tGet stack sources using HTTPS"
|
|
|
- print " -g\t\t\tGet stack sources using GIT protocol (SSH)"
|
|
|
- print " -F\t\t\tForce mode, rebuild the Stage area"
|
|
|
- print " -r\t\t\tReset environment"
|
|
|
-
|
|
|
- print
|
|
|
- print ANSI_BOLD + ANSI_WHITE + "Profiling and Trace" + ANSI_RESET
|
|
|
- print " -A\t\t\tUse libc memory allocator instead of Jemalloc (disabled)"
|
|
|
- print " -X\t\t\tEnable Jemalloc statistics (disabled)"
|
|
|
- print " -J\t\t\tEnable Jemalloc profiling and leaks detection (disabled)"
|
|
|
- print " -T\t\t\tEnable Linux Trace Toolkit (disabled)"
|
|
|
-
|
|
|
- print
|
|
|
- print ANSI_BOLD + ANSI_WHITE + "HTTP Server Options" + ANSI_RESET
|
|
|
- print " -p TCP_PORT\t\tSet TCP port (default 2001)"
|
|
|
- print " -w WEB_SERVICE\tSpecify web service source path"
|
|
|
- print " -S\t\t\tWeb Service will run with SSL mode enabled"
|
|
|
- print " -M 'k1=v1,kn=vn'\tOverride some web server config key/value"
|
|
|
-
|
|
|
- print
|
|
|
- print ANSI_BOLD + ANSI_WHITE + "Others" + ANSI_RESET
|
|
|
- print " -h\t\t\tPrint this help"
|
|
|
- print " -u\t\t\tRedirect server output to STDOUT"
|
|
|
- print " -v\t\t\tPrint version"
|
|
|
-
|
|
|
- # it creates a configuration schema to override the values of the main
|
|
|
- # Monkey configuration file
|
|
|
- def conf_schema(self, value):
|
|
|
- if value.find(',') > 0:
|
|
|
- entries = value.split(',')
|
|
|
- if len(entries) == 0:
|
|
|
- return None
|
|
|
- else:
|
|
|
- key, val = value.split('=')
|
|
|
- if len(key) == 0 or len(val) == 0:
|
|
|
- print "Error: Invalid configuration schema '%s'" % value
|
|
|
- exit(1)
|
|
|
-
|
|
|
- return {key: val}
|
|
|
-
|
|
|
- # Lookup all entries in the value
|
|
|
- c = {}
|
|
|
- for e in entries:
|
|
|
- key, val = e.split('=')
|
|
|
- if len(key) == 0 or len(val) == 0:
|
|
|
- print "Error: Invalid configuration schema '%s'" % value
|
|
|
- exit(1)
|
|
|
- c[key] = val
|
|
|
-
|
|
|
- return c
|
|
|
-
|
|
|
- def get_arguments(self):
|
|
|
- update = None
|
|
|
- monkey_conf = None
|
|
|
- self.api_level = "dst-%i" % int(DEFAULT_API_LEVEL)
|
|
|
-
|
|
|
- # Reading command line arguments
|
|
|
- try:
|
|
|
- optlist, args = getopt.getopt(sys.argv[1:], 'V:sgFrhvSuw:p:AXJTM:')
|
|
|
- except getopt.GetoptError:
|
|
|
- self.print_help()
|
|
|
- sys.exit(2)
|
|
|
-
|
|
|
- if len(optlist) == 0:
|
|
|
- self.print_help()
|
|
|
-
|
|
|
- # Check options
|
|
|
- for op, arg in optlist:
|
|
|
- if op == '-s':
|
|
|
- update = PROTOCOL_HTTPS
|
|
|
- elif op == '-g':
|
|
|
- update = PROTOCOL_GIT
|
|
|
- elif op == '-F':
|
|
|
- self.rebuild_monkey = True
|
|
|
- elif op == '-r':
|
|
|
- self.reset()
|
|
|
- exit(0)
|
|
|
- elif op == '-V':
|
|
|
- self.api_level = arg
|
|
|
- elif op == '-S':
|
|
|
- self.SSL = True
|
|
|
- elif op == '-h':
|
|
|
- self.print_help()
|
|
|
- sys.exit(0)
|
|
|
- elif op == '-p':
|
|
|
- if not str(arg).isdigit():
|
|
|
- self.print_help()
|
|
|
- exit(1)
|
|
|
- self.port = arg
|
|
|
- elif op == '-A':
|
|
|
- self.linux_malloc = True
|
|
|
- elif op == '-X':
|
|
|
- self.jemalloc_stats = True
|
|
|
- elif op == '-J':
|
|
|
- self.jemalloc_prof = True
|
|
|
- elif op == '-M':
|
|
|
- monkey_conf = arg
|
|
|
- elif op == '-D':
|
|
|
- self.service_macros = arg
|
|
|
- elif op == '-T':
|
|
|
- self.linux_trace = True
|
|
|
- elif op == '-u':
|
|
|
- self.output_stdout = True
|
|
|
- elif op == '-v':
|
|
|
- sys.exit(0)
|
|
|
- break
|
|
|
- elif op == '-w':
|
|
|
- self.service = arg
|
|
|
- self.config_requirements()
|
|
|
-
|
|
|
- # SSL
|
|
|
- if self.SSL is True:
|
|
|
- self.monkey.SSL = True
|
|
|
-
|
|
|
- # Enable Jemalloc profiling
|
|
|
- if 'JEMALLOC_OPTS' not in os.environ:
|
|
|
- os.environ['JEMALLOC_OPTS'] = ''
|
|
|
-
|
|
|
- if self.jemalloc_prof is True:
|
|
|
- os.environ['JEMALLOC_OPTS'] += '--enable-prof'
|
|
|
- os.environ['JE_MALLOC_CONF'] = 'prof_leak:true,prof:true,prof_prefix:duda.jeprof'
|
|
|
-
|
|
|
- # More environment vars: make will use 8 jobs
|
|
|
- os.environ['MAKEFLAGS'] = '-j 8'
|
|
|
-
|
|
|
- # Linux Trace Toolkit
|
|
|
- if self.linux_trace is True:
|
|
|
- self.monkey.opts += "--linux-trace "
|
|
|
-
|
|
|
- # Use system malloc instead Jemalloc
|
|
|
- if self.linux_malloc is True:
|
|
|
- self.monkey.opts += "--malloc-libc "
|
|
|
-
|
|
|
- # Jemalloc Stats
|
|
|
- if self.linux_malloc is False and self.jemalloc_stats is True:
|
|
|
- os.environ['JEMALLOC_OPTS'] += ' --enable-stats'
|
|
|
-
|
|
|
- # Rebuild the stack ?
|
|
|
- if update is not None:
|
|
|
- if self.rebuild_monkey is True:
|
|
|
- print "Error: you cannot mix the flag -f with -g or -s"
|
|
|
- exit(1)
|
|
|
-
|
|
|
- if self.dudac_stage_path is None:
|
|
|
- self.update_framework(update)
|
|
|
- else:
|
|
|
- print_msg("DUDAC_STAGE_PATH is set")
|
|
|
-
|
|
|
- # Override Monkey configuration. It will create the configuration
|
|
|
- # schema which is used later by the run_webservice() method.
|
|
|
- if monkey_conf:
|
|
|
- mconf_schema = self.conf_schema(monkey_conf)
|
|
|
- else:
|
|
|
- mconf_schema = None
|
|
|
-
|
|
|
- # Run web service
|
|
|
- if self.service:
|
|
|
- self.run_webservice(mconf_schema)
|
|
|
-
|
|
|
- def _temp_path(self):
|
|
|
- pass
|
|
|
-
|
|
|
-def main():
|
|
|
- d = Duda()
|
|
|
-
|
|
|
-if __name__ == '__main__':
|
|
|
- main()
|
Hamilton Turner