def __init__(self, runtime_env, ini_file="config.ini", os=None):
self.logger = Logger(log_level=0, console_level=3)
self.sts = Settings(self.logger, runtime_env, ini_file=ini_file) # sts
self.logger.set_console_level(self.sts.debug_level)
self.logger.set_log_level(0)
self.comfun = CommonFunctions(self.logger)
if os is None:
self.os = platform.system()
if self.os == "Windows":
self.os = "w"
elif self.os == "Linux":
self.os = "l"
else:
self.os = None
# abbreviation for very often used variables, helping with identification the main modules
self.usr = Users(self) # usr
self.prj = Projects(self) # prj
self.sch = Schemas(self) # sch
self.tsk = Tasks(self) # tsk
self.que = Queue(self) # que
self.nod = SimNodes(self) # nod
self.dfn = Definitions(self) # dfn
self.sio = StorageInOut(self) # sio
# abbreviation END
self.logger.inf("SimBatch started")
def __init__(self, changelog_reader):
# Administrator keyids.
# Return a *deterministic* "keyid" for the snapshot administrator.
# WARNING: Do *NOT* reuse this value anywhere else!
# It just so happens that a SHA-256 hex digest is as long as our keyid.
self.__snapshot_administrator_keyid = \
MetadataWriter.get_sha256('snapshot'.encode('utf-8'))
self.__projects_administrator_keyid = MetadataWriter.get_random_keyid()
self.__projects_subordinates_keyid = self.__projects_administrator_keyid
# Administrator keyvals.
self.__keyid_to_keyval = {
self.__snapshot_administrator_keyid:
MetadataWriter.get_random_ed25519_keyval(),
self.__projects_administrator_keyid:
MetadataWriter.get_random_ed25519_keyval()
}
# Administrator versions.
self.__snapshot_administrator_version = 0
self.__projects_administrator_version = 0
# A map of which projects subordinates are responsible for which projects.
# str (role name): {str} (set of project names)
self._projects_subordinates_to_projects = {}
# str (role name): int (version number > 0)
self._projects_subordinates_to_version = {}
# This object takes care of projects and their packages, keys, etc.
self.__projects = Projects(changelog_reader)
# Custom setup routine here.
self._setup()
def __init__(self, project):
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.build_system = BrickConfig().get('build', 'system')
self.build_options = BuildOptions(self.git.workdir)
self.build_container = None
self.workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'),
self.project.name,
)
self.real_workspace = "%s/%s" % (BrickConfig().get(
'workspace', 'dir'), self.project.name)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}')
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp')
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def test_list_projects(make_stubber, stub_runner, monkeypatch, error_code,
stop_on_method):
lookoutvision_client = boto3.client('lookoutvision')
lookoutvision_stubber = make_stubber(lookoutvision_client)
project_name = 'test-project'
project_arn = 'test-arn'
created = datetime.datetime.now()
model_version = 'test-model'
dataset = {'DatasetType': 'testing', 'StatusMessage': 'nicely tested'}
monkeypatch.setattr(Models, 'describe_model', lambda x, y, z: None)
with stub_runner(error_code, stop_on_method) as runner:
runner.add(lookoutvision_stubber.stub_list_projects, [project_name],
[{
'arn': project_arn,
'created': created
}])
runner.add(lookoutvision_stubber.stub_describe_project, project_name,
[dataset])
runner.add(lookoutvision_stubber.stub_list_models, project_name,
[model_version])
if error_code is None:
Projects.list_projects(lookoutvision_client)
else:
with pytest.raises(ClientError) as exc_info:
Projects.list_projects(lookoutvision_client)
assert exc_info.value.response['Error']['Code'] == error_code
def delete(self, name):
try:
project = Projects(name)
git = Git(project)
git.clear_repo()
project.clear_branches()
project.delete()
self.write(cyclone.escape.json_encode({'status': 'project deleted'}))
except Exception, e:
log.err(e)
self.write(cyclone.escape.json_encode({'status': 'failed to delete %s' % str(e)}))
def delete(self, name):
log.msg("deleting project %s" % name)
try:
project = Projects(name)
git = Git(project)
git.clear_repo()
project.clear_branches()
project.delete()
self.write(cyclone.escape.json_encode({"status": "project deleted"}))
except Exception, e:
log.err(e)
self.write(cyclone.escape.json_encode({"status": "failed to delete %s" % str(e)}))
def put(self, name):
project = Projects(name)
try:
for aname, arg in self.request.arguments.iteritems():
if aname in ('branch'):
branch = arg
else:
setattr(project, aname, arg[0])
project.save()
except Exception, e:
log.err(e)
self.finish(cyclone.escape.json_encode({'status': 'fail'}))
def main_launch_project(args, input, state, output):
projects = Projects()
try_restore_previous_state(input, "y", state)
# It is not possible to instruct Visual Studio to start with a specific
# configuration so we do not ask the user and randomly specify "x64"
selected_architecture = "x64"
compilers = Compilers(selected_architecture)
compiler = compilers.select_compiler(input, state, output)
projects.get(args.launch).launch(compiler)
def test_delete_project(make_stubber, error_code):
lookoutvision_client = boto3.client('lookoutvision')
lookoutvision_stubber = make_stubber(lookoutvision_client)
project_name = 'test-project_name'
project_arn = 'test-arn'
lookoutvision_stubber.stub_delete_project(project_name,
project_arn,
error_code=error_code)
if error_code is None:
Projects.delete_project(lookoutvision_client, project_name)
else:
with pytest.raises(ClientError) as exc_info:
Projects.delete_project(lookoutvision_client, project_name)
assert exc_info.value.response['Error']['Code'] == error_code
def select_client(client_selection):
client_label['text'] = f'Client: {client_selection}'
project = Projects(workspaceId, clients.clients[client_selection])
toggle_client_selection_off()
scratch_pad.focus_set()
payload['start'] = datetime.now(tz=timezone.utc).isoformat().replace(
"+00:00", "Z")
project_name_and_id.update(
{p['name']: p['id']
for p in project.project_client})
if len(project_name_and_id) > 1:
project_frame = ProjectButtons(button_frame, borderwidth=5)
project_frame.grid(row=0, column=1, sticky=tk.NSEW)
project_buttons = [
ttk.Button(
project_frame,
text=project_item,
command=lambda project_item=project_item: select_project(
project_name_and_id[project_item], project_frame))
for project_item in project_name_and_id.keys()
]
set_button_location(project_buttons)
else:
payload['projectId'] = [
value for value in project_name_and_id.values()
][0]
def __init__(self, project):
self.workspace = BrickConfig().get('workspace', 'dir')
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.workdir = self.git.workdir
self.build_system = BrickConfig().get('build', 'system')
self.ftp_host = BrickConfig().get('ftp', 'host')
self.ftp_user = BrickConfig().get('ftp', 'user')
self.ftp_pass = BrickConfig().get('ftp', 'pass')
self.ftp_dir = BrickConfig().get('ftp', 'dir')
if self.build_system == 'rpm':
self.package_builder = RpmBuilder(self)
elif self.build_system == 'deb':
self.package_builder = DebBuilder(self)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}'
)
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp'
)
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def __init__(self, project):
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.build_system = BrickConfig().get('build', 'system')
self.build_options = BuildOptions(self.git.workdir)
self.build_container = None
self.workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'),
self.project.name,
)
self.real_workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'), self.project.name
)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}'
)
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp'
)
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def main():
"""
Creates and optionally starts an Amazon Lookout for Vision model using
command line arguments.
A new project, training dataset, optional test dataset, and model are created.
After model training is completed, you can use the code in inference.py to try your
model with an image.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
parser.add_argument("project", help="A unique name for your project")
parser.add_argument(
"bucket",
help=
"The bucket used to upload your manifest files and store training output"
)
parser.add_argument(
"training",
help="The S3 path where the service gets the training images.")
parser.add_argument(
"test",
nargs="?",
default=None,
help="(Optional) The S3 path where the service gets the test images.")
args = parser.parse_args()
project_name = args.project
bucket = args.bucket
training_images = args.training
test_images = args.test
lookoutvision_client = boto3.client("lookoutvision")
s3_resource = boto3.resource("s3")
print(f"Storing information in s3://{bucket}/{project_name}/")
print("Creating project...")
Projects.create_project(lookoutvision_client, project_name)
create_dataset(lookoutvision_client, s3_resource, bucket, project_name,
training_images, "train")
if test_images is not None:
create_dataset(lookoutvision_client, s3_resource, bucket, project_name,
test_images, "test")
# Train the model and optionally start hosting.
train_model(lookoutvision_client, bucket, project_name)
def __new_charge(self, curr_snapshot_timestamp, url):
assert url.startswith('/')
package_relpath = url[1:]
package_cost = PackageCost()
# 1. Precomputed snapshot metadata cost.
curr_snapshot_metadata_relpath = \
'snapshot.{}.json'.format(curr_snapshot_timestamp)
curr_snapshot_metadata_cost = \
self.__COST_FOR_NEW_USERS[curr_snapshot_metadata_relpath]
snapshot_metadata_length = \
curr_snapshot_metadata_cost['snapshot_metadata_length']
logging.debug('Prev, curr snapshot = {}, {}'\
.format(self._prev_snapshot_metadata_relpath,
curr_snapshot_metadata_relpath))
logging.debug('Snapshot metadata length = {:,}'\
.format(snapshot_metadata_length))
self._prev_prev_snapshot_metadata_relpath = \
self._prev_snapshot_metadata_relpath
self._prev_snapshot_metadata_relpath = curr_snapshot_metadata_relpath
package_cost.snapshot_metadata_length = snapshot_metadata_length
snapshot_metadata = self._read_snapshot(curr_snapshot_metadata_relpath)
project_name = Projects.get_project_name_from_package(url)
project_metadata_relpath = 'packages/{}.json'.format(project_name)
# Does the project of the desired package exist in this snapshot?
if project_metadata_relpath in snapshot_metadata:
# 2. Precomputed total project metadata cost.
project_metadata_length = \
curr_snapshot_metadata_cost['project_metadata_length']
logging.debug('Project metadata length = {:,}'\
.format(project_metadata_length))
package_cost.add_project_metadata_length(project_metadata_length)
# Find the package itself.
project_metadata_identifier = snapshot_metadata[project_metadata_relpath]
curr_project_metadata_relpath = 'packages/{}.{}.json'\
.format(project_name,
project_metadata_identifier)
project_metadata = self._read_project(curr_project_metadata_relpath)
package_metadata = project_metadata.get(package_relpath)
# Does the desired package itself exist now in the project?
if package_metadata:
# 4. Fetch the package itself, according to the latest project
# metadata.
package_length = package_metadata['length']
package_cost.package_length = \
self.get_cached_package_cost(package_relpath, package_length)
logging.debug('Package length = {:,}'\
.format(package_length))
logging.debug('Package cost = {}'.format(package_cost))
return package_cost
else:
raise UnknownPackage(package_relpath)
else:
raise UnknownProject(project_name)
def main_bootstrap_build(args, input, state, output):
try:
print("")
output.print_main_title()
try_restore_previous_state(input, "n", state)
target = select_target(input, state, output)
Path("Build").mkdir(exist_ok=True)
dependencies = Dependencies()
dependencies.check(output)
projects = Projects(target)
projects.set_environment_variables(output)
download_source_packages(projects, args.skip_downloads, input, state,
output)
compilers = Compilers(target)
compiler = compilers.select_compiler(input, state, output)
build_configuration = BuildConfiguration()
build_configuration.select_configuration(target.architecture,
compiler, input, state)
cmake = CMake(compiler.cmake_generator)
cmake.install(target, state, output)
codesmithymake = CodeSmithyMake(target.architecture)
build_tools = BuildTools(cmake, compiler, codesmithymake)
projects.build(build_tools, build_configuration,
input, state, output)
print("")
output.print_step_title("Running tests")
if args.skip_tests:
print(" Skipping tests")
else:
projects.test(compiler, build_configuration.architecture_dir_name,
input)
output.next_step()
print("")
output.print_step_title("Setting up second-phase of bootstrap")
second_phase_path = str(Path(os.getcwd()).parent) + \
"/SecondPhaseBootstrap"
Path(second_phase_path).mkdir(exist_ok=True)
print(second_phase_path)
# TODO
shutil.copyfile("Build/CodeSmithyIDE/CodeSmithy/Bin/x64/CodeSmithy.exe", second_phase_path + "/CodeSmithy.exe")
output.next_step()
except RuntimeError as error:
print("")
print("ERROR:", error)
sys.exit(-1)
def put(self, name):
project = Projects(name)
try:
for aname, arg in self.request.arguments.iteritems():
if aname in ("branch"):
branch = arg
else:
setattr(project, aname, arg[0])
json_data = json.loads(self.request.body)
if len(json_data.keys()) > 0:
for k, v in json_data.iteritems():
setattr(project, k, v)
project.save()
except Exception, e:
log.err(e)
self.finish(cyclone.escape.json_encode({"status": "fail"}))
def put(self, name):
project = Projects(name)
try:
for aname, arg in self.request.arguments.iteritems():
if aname in ('branch'):
branch = arg
else:
setattr(project, aname, arg[0])
json_data = json.loads(self.request.body)
if len(json_data.keys()) > 0:
for k, v in json_data.iteritems():
setattr(project, k, v)
project.save()
except Exception, e:
log.err(e)
self.finish(cyclone.escape.json_encode({'status': 'fail'}))
def draw_on_image_version_2(self, database, x_image, y_image):
list_of_arguments = ["name", "main_color", "budget_value", "budget_currency"]
list_from_sql = database.run_sql_command("""SELECT name, main_color, budget_value, budget_currency FROM project
WHERE name IS NOT NULL and main_color IS NOT NULL;""")
projects_object_list = Projects.get_projects_object_list(list_of_arguments, list_from_sql)
list_text_objects = []
for element in projects_object_list:
list_text_objects.append(
Texts(element.name, self.current_file_path + "/fonts/28_days_later.ttf", int(element.budget_eur / 250),
element.main_color[0],
element.main_color[1], element.main_color[2]))
self.draw_list_text_objects(list_text_objects, x_image, y_image)
def post(self, project_name):
try:
project = Projects(project_name)
git = Git(project)
git.clear_repo()
self.write(cyclone.escape.json_encode({'status': 'ok'}))
except Exception, e:
self.write(
cyclone.escape.json_encode({
'status': 'fail',
'error': str(e)
}))
def search_projects():
# get the vales from the box and from the combo
type_ = seach_project_combo.get()
search_text = search_projects_entry.get()
if search_text == "" or type_ == "":
print('Fill Both entrys')
return
global search_term
if type_ == 'Customer Name':
search_term = 'customer_name'
# fire over to 'find customer' return all projects under matching customers
elif type_ == 'Primay Contant':
search_term = 'primary_conatact'
# fire over to 'find contact' return all project under matching contact
projects_found = 'primay constat'
print('not yet implemented')
elif type_ == 'Project Name':
search_term = 'project_name'
elif type_ == 'Refrence':
search_term = 'project_refrence'
elif type_ == 'Address':
search_term = 'project_address'
elif type_ == 'Post Code':
search_term = 'project_postcode'
elif type_ == 'Triage':
search_term = 'project_triage'
search_text = search_text
if type_ == 'Customer Name' or type_ == 'Primary Contact':
if type_ == 'Customer Name':
display_search(Projects.search_by_cust_name(search_text))
else:
results = Projects.find_project(search_text, search_term)
display_search((Projects.find_project(search_text,
search_term)))
def __init__(self,
username=None,
password=None,
access_token=None,
request=None):
self.request = request or PlayNicelyRequest(username, password)
self.projects = Projects(self.request)
self.milestones = Milestones(self.request)
self.items = Items(self.request)
self.users = Users(self.request)
self.echo = Echo(self.request)
def select_project():
# slect a project high lighted in the tree view
# find the project based upon id, load from database
focus = projects_tree.focus()
project_selected = projects_tree.item(focus)
global current_project, current_customer
project_id = project_selected['values'][7]
customer_id = project_selected['values'][8]
current_customer = Customer.find_customer(customer_id, 'id')[0]
current_project = Projects.find_project(project_id,
'project_id')[0]
up_project_labels()
def execute(cfg):
users = Users(cfg).run()
base.storage('users', users)
groups = Groups(cfg).run()
base.storage('groups', groups)
members = GroupsMembers(cfg, users, groups).run()
base.storage('groups-members', members)
projects = Projects(cfg, users['target'], groups['target']).run()
base.storage('projects', projects)
Repositories(cfg, projects['source']).run()
def add_project_to_db(entry_list):
# take all the details from the page and add a new prject, make sure to check that the input is valid
# and that the project does not exsist
#get the info from the boxes, pass it to the project method
new_project = Projects(
entry_list['Customer ID'].get(),
entry_list['Project Name'].get(),
entry_list['Project Reference'].get(),
entry_list['Project Address'].get(),
entry_list['Project Postcode'].get(),
entry_list['Primary Contact'].get(),
entry_list['Project Type'].get(),
entry_list['Project Price Approx'].get(),
'',
entry_list['Project Expected Profit'].get(),
'',
entry_list['Project Triage'].get(),
entry_list['Project Lead MES'].get(),
'',
'',
)
# print(new_project)
new_project.save_to_db()
def post(self, project_name):
branch = self.get_argument('branch')
project = Projects(project_name)
if branch in project.branches():
self.write(cyclone.escape.json_encode({'status': 'failed: branch already exist'}))
else:
project.add_branch(branch)
project.version(branch, '0.1')
reactor.callInThread(queue.enqueue, 'build', 'builder.build_project', {'project': project.name, 'branch': self.get_argument('branch'), 'force': True})
self.write(cyclone.escape.json_encode({'status': 'ok'}))
def post(self, project_name):
project = Projects(project_name)
release = self.get_argument('tag')
version = self.get_argument('version')
commit = self.get_argument('commit', default=None)
reactor.callInThread(
queue.enqueue, 'build', 'builder.build_project', {
'project': project.name,
'branch': 'master',
'release': release,
'version': version,
'commit': commit,
})
self.write(
cyclone.escape.json_encode(
{'status': 'build of branch %s scheduled' % release}))
def execute(cfg):
# cachepath = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),'cache')
users = Users(cfg).run()
#with open(cachepath + '/users.json','r') as f:
# users = json.load(f)
groups = Groups(cfg).run()
#with open( cachepath + '/groups.json','r') as f:
# groups = json.load(f)
members = GroupsMembers(cfg, users, groups).run()
projects = Projects(cfg, users, groups).run()
# with open( cachepath + '/projects.json','r') as f:
# projects = json.load(f)
Repositories(cfg, projects).run()
def post(self, project_name):
branch = self.get_argument("branch")
project = Projects(project_name)
if branch in project.branches():
self.write(cyclone.escape.json_encode({"status": "failed: branch already exist"}))
else:
project.add_branch(branch)
project.version(branch, "0.1")
reactor.callInThread(
build_project,
{"project": project.name, "branch": self.get_argument("branch"), "release": "experimental"},
)
self.write(cyclone.escape.json_encode({"status": "ok"}))
def display_search(project_list):
# create a list of all projects matching serch criteria, if customer name list all projects beling to naem or names
projects_tree.grid(row=1, column=0, columnspan=8)
projects_tree.delete(*projects_tree.get_children())
if type(project_list) == list:
_list = []
for project in project_list:
_list.append(
Projects(
project[1],
project[2],
project[3],
project[4],
project[5],
project[6],
project[7],
project[8],
project[9],
project[10],
project[11],
project[12],
project[13],
project[14],
project[0],
))
project_list = _list
for projects in project_list:
projects_tree.insert('',
'end',
text='project details',
values=(
Customer.get_customer_name_by_id(
projects.customer_id),
projects.project_name,
projects.primary_contact,
projects.project_reference,
projects.project_address,
projects.project_postcode,
projects.project_triage,
projects.project_id,
projects.customer_id,
))
def post(self, project_name):
branch = self.get_argument('branch')
project = Projects(project_name)
if branch in project.branches():
self.write(
cyclone.escape.json_encode(
{'status': 'failed: branch already exist'}))
else:
project.add_branch(branch)
project.version(branch, '0.1')
reactor.callInThread(
queue.enqueue, 'build', 'builder.build_project', {
'project': project.name,
'branch': self.get_argument('branch'),
'release': 'experimental'
})
self.write(cyclone.escape.json_encode({'status': 'ok'}))
def delete(self, name):
log.msg("deleting project %s" % name)
try:
project = Projects(name)
git = Git(project)
git.clear_repo()
project.clear_branches()
project.delete()
self.write(
cyclone.escape.json_encode({'status': 'project deleted'}))
except Exception, e:
log.err(e)
self.write(
cyclone.escape.json_encode(
{'status': 'failed to delete %s' % str(e)}))
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
from jsonbackend import JsonBackend
from optparse import OptionParser
from projects import Projects
import logging
import os
import time
projects = Projects('tm.po')
add_source = True
projects_names = None
projects_json = 'projects.json'
only_all_projects_tm = None
softcatala_only = None
def init_logging():
logfile = 'builder.log'
if os.path.isfile(logfile):
os.remove(logfile)
logging.basicConfig(filename=logfile, level=logging.DEBUG)
logger = logging.getLogger('')
class SimBatch:
s = None
comfun = None
logger = None
os = None
def __init__(self, runtime_env, ini_file="config.ini", os=None):
self.logger = Logger(log_level=0, console_level=3)
self.sts = Settings(self.logger, runtime_env, ini_file=ini_file) # sts
self.logger.set_console_level(self.sts.debug_level)
self.logger.set_log_level(0)
self.comfun = CommonFunctions(self.logger)
if os is None:
self.os = platform.system()
if self.os == "Windows":
self.os = "w"
elif self.os == "Linux":
self.os = "l"
else:
self.os = None
# abbreviation for very often used variables, helping with identification the main modules
self.usr = Users(
self,
mode=1) # usr """ users are fully implemented in Pro version """
self.prj = Projects(self) # prj
self.sch = Schemas(self) # sch
self.tsk = Tasks(self) # tsk
self.que = Queue(self) # que
self.nod = SimNodes(self) # nod
self.dfn = Definitions(self) # dfn
self.sio = StorageInOut(self) # sio
self.pat = Patterns() # pat
# abbreviation END
self.logger.inf("SimBatch {} started".format(self.sts.get_version()),
nl=True,
nl_after=True)
def print_data(self):
self.prj.print_all()
def print_important_values(self):
print " \n\n Current runtime_env: {}".format(self.sts.runtime_env)
# projects
print "\n PROJECTS: "
self.prj.print_current()
# schemas
print "\n SCHEMAS: "
self.sch.print_current()
# tasks
print "\n TASKS: "
self.tsk.print_current()
# queue
print "\n QUEUE: "
self.que.print_current()
# nodes
print "\n NODES: "
self.nod.print_current()
# nodes
print "\n DEFINITIONS: "
self.dfn.print_current()
print "\n\n"
def print_current_detailed_values(self, index):
print " \n\n"
if self.sts.ui_edition_mode == 0: # open source no wizard tab
index += 1 # index compensation
if index == 0:
print " WIZARD: "
if index == 1:
print " PROJECTS: "
self.prj.print_all()
self.prj.print_current()
if index == 2:
print " SCHEMAS: "
self.sch.print_all()
self.sch.print_current()
if index == 3:
print " TASKS: "
self.tsk.print_all()
self.tsk.print_current()
if index == 4:
print " QUEUE: "
self.que.print_all()
self.que.print_current()
if index == 5:
print " SIMNODES: "
self.nod.print_all()
self.nod.print_current()
if index == 6:
print " DEFINITIONS: "
self.dfn.print_all()
self.dfn.print_current()
if index == 7:
print " SETTINGS: "
self.sts.print_all()
print "\n\n"
def clear_all_stored_data(self):
self.prj.clear_all_projects_data(clear_stored_data=True)
self.sch.clear_all_schemas_data(clear_stored_data=True)
def clear_all_memory_data(self):
self.prj.clear_all_projects_data()
self.sch.clear_all_schemas_data()
def loading_errors(self, check_this, counter, msg):
if self.comfun.is_int(check_this):
counter += check_this
self.logger.err(
"Loading error! File: ({}) file errors count:{}".format(
msg, check_this))
return counter
def load_data(self):
if self.sts.loading_state >= 4:
ret_def = self.dfn.load_definitions()
if self.sio.check_any_data_to_load_exist():
ret_prj = self.prj.load_projects()
if ret_prj is not False:
self.prj.init_default_proj()
ret_sch = self.sch.load_schemas()
if ret_sch is not False:
ret_tsk = self.tsk.load_tasks()
if ret_tsk is not False:
ret_que = self.que.load_queue()
if ret_que is not False:
ret_nod = self.nod.load_nodes()
if ret_nod is not False:
loading_err_count = 0 # count number errors while of loading external data
loading_err_count = self.loading_errors(
ret_def, loading_err_count,
"definitions")
loading_err_count = self.loading_errors(
ret_prj, loading_err_count, "project")
loading_err_count = self.loading_errors(
ret_sch, loading_err_count, "schemas")
loading_err_count = self.loading_errors(
ret_tsk, loading_err_count, "tasks")
loading_err_count = self.loading_errors(
ret_tsk, loading_err_count, "queue")
loading_err_count = self.loading_errors(
ret_tsk, loading_err_count, "simnodes")
if loading_err_count == 0:
return True, ""
else:
return loading_err_count, "error info in log"
else:
return -5, "SimNodes not loaded"
else:
return -4, "Queue items not loaded"
else:
return -1, "Tasks data not loaded"
else:
return -2, "Schemas data not loaded"
else:
return -3, "Projects data not loaded"
else:
return -100, "No data exist"
else:
return False, "config.ini not loaded"
def get(self, name='', branch='master'):
try:
if name:
project = Projects(name)
reply = {
'name': project.name,
'branch': project.branches(),
'experimental': int(project.experimental),
'group_name': project.group_name,
'git_url': project.git_url,
'version': project.version(),
'last_tag_testing': project.last_tag(tag_type='testing'),
'last_tag_stable': project.last_tag(tag_type='stable'),
'last_tag_unstable': project.last_tag(tag_type='unstable'),
'last_commit': project.last_commit(branch)
}
else:
projects = Projects.get_all()
reply = []
for project in projects:
reply.append({
'name':
project.name,
'branch':
project.branches(),
'experimental':
int(project.experimental),
'group_name':
project.group_name,
'git_url':
project.git_url,
'version':
project.version(),
'last_tag_testing':
project.last_tag(tag_type='testing'),
'last_tag_stable':
project.last_tag(tag_type='stable'),
'last_tag_unstable':
project.last_tag(tag_type='unstable'),
'last_commit':
project.last_commit(branch)
})
self.write(cyclone.escape.json_encode(reply))
except Exception, e:
self.write(cyclone.escape.json_encode("%s No project found" % e))
class Builder:
def __init__(self, project):
self.workspace = BrickConfig().get('workspace', 'dir')
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.build_system = BrickConfig().get('build', 'system')
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}'
)
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp'
)
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def _exec(self, cmd, *args, **kwargs):
return subprocess.Popen(cmd, *args, **kwargs)
def build_project(self, branch=None, release=None, version=None):
if not self.project.is_building():
self.project.start_building()
try:
self.workdir = "%s-%s" % (self.git.workdir, release)
shutil.copytree(self.git.workdir, self.workdir)
if self.build_system == 'rpm':
self.package_builder = RpmBuilder(self)
elif self.build_system == 'deb':
self.package_builder = DebBuilder(self)
os.chdir(self.workdir)
self.git.workdir = self.workdir
self.git.checkout_branch(branch)
if release == 'experimental':
self.git.checkout_branch(branch)
self.package_builder.build(branch, release)
self.package_builder.upload(branch)
else:
self.project.last_tag(release, self.git.last_tag(release))
self.git.checkout_tag(self.project.last_tag(release))
self.package_builder.build(branch, self.project.last_tag(release))
self.package_builder.upload(release)
self.git.checkout_branch('master')
shutil.rmtree(self.workdir)
except Exception, e:
log.exception("build failed: %s" % repr(e))
finally:
def post(self, *args):
if len(args) >= 1:
name = args[0]
project = Projects(name)
for key, value in self.request.arguments.iteritems():
if key in ("git_url", "version", "build_cmd", "install_cmd"):
setattr(project, key, value[0])
project.save()
try:
if not Projects(self.get_argument('name')).exists():
raise
except Exception, e:
project = Projects()
project.name = self.get_argument('name')[0]
project.git_url = self.get_argument('git_url')[0]
for name, parm in self.request.arguments.iteritems():
if name not in ('branch', 'version'):
setattr(project, str(name), parm[0])
try:
project.add_branch(self.get_argument('branch'))
project.version(self.get_argument('branch'),
self.get_argument('version'))
project.group_name = self.get_argument('group_name')
project.save()
log.msg('Project created:', project.name)
reactor.callInThread(
queue.enqueue, 'build', 'builder.build_project', {
'project': project.name,
'branch': self.get_argument('branch'),
'release': 'experimental'
})
self.write(cyclone.escape.json_encode({'status': 'ok'}))
except Exception, e:
log.err()
self.write(cyclone.escape.json_encode({'status': "fail"}))
def expand_frame(task):
# make a new function to disaplay a task in full view, contaning all info that is editible
# get all info for the customer, the project, contacts etc.
project_for_frame = Projects.find_project(
task.project_id, 'project_id')[0]
customer_for_frame = Customer.find_customer(
project_for_frame.customer_id, 'id')[0]
task_win = tk.Toplevel()
task_win.wm_title(
f'{task.task_description} :---: {project_for_frame.project_name} :---: {customer_for_frame.name} :---:'
)
task_frame = ttk.Frame(task_win)
#add some meaningfull info to the frame, make it editible and saveable to the database,
#section for the customer
#key contact deets, add contact to customer, change contact deets
project_lable_frame = ttk.LabelFrame(task_frame,
text='Project')
project_lable_frame.grid(row=0, column=0)
customer_lable_frame = ttk.LabelFrame(task_frame,
text='Customer',
padding=14.7)
customer_lable_frame.grid(row=1, column=0)
#get all the labels from customer
#add allthe names and items to a dictinarry
#make entrys (labeled - properley) for all relevetn customer items
customer_labels = [
'customer_name',
'customer_address',
'customer_postcode',
'customer_phone',
'customer_mobile',
'customer_email',
'customer_type',
'customer_id',
]
customer_entry = {}
customer_entry_label = {}
for i, _name in enumerate(customer_labels):
e = ttk.Entry(customer_lable_frame)
entry[_name] = e
e.grid(sticky='e', column=1)
lb = ttk.Label(customer_lable_frame,
text=_name[9:].title())
lb.grid(row=i, column=0, sticky='w')
e.insert(0, getattr(customer_for_frame, f'{_name[9:]}'))
project_labels = {
'Project Name': 'project_name',
'Project Reference': 'project_reference',
'Project Address': 'project_address',
'Project Postcode': 'project_postcode',
'Primary Contact': 'primary_contact',
'Project Type': 'project_type',
'Project Price Approx': 'project_price_approx',
'Project Expected Profit': 'project_expected_profit',
'Project Triage': 'project_triage',
'Project Lead MES': 'project_lead_mes',
}
for i, _name in enumerate(project_labels.keys()):
e = ttk.Entry(project_lable_frame)
entry[_name] = e
e.grid(sticky='e', column=1)
lb = ttk.Label(project_lable_frame, text=_name[8:])
lb.grid(row=i, column=0, sticky='w')
# make something to convert list names to actual
e.insert(0,
getattr(project_for_frame, project_labels[_name]))
#customer_name_entry.insert(0,customer_for_frame.name)
task_frame.grid()
def post(self, *args):
if len(args) >= 1:
name = args[0]
project = Projects(name)
for key, value in self.request.arguments.iteritems():
if key in ("git_url", "version", "build_cmd", "install_cmd"):
setattr(project, key, value[0])
project.save()
try:
if not Projects(self.get_argument('name')).exists():
raise
except Exception, e:
project = Projects()
project.name = self.get_argument('name')[0]
project.git_url = self.get_argument('git_url')[0]
for name, parm in self.request.arguments.iteritems():
if name not in ('branch', 'version'):
setattr(project, str(name), parm[0])
try:
project.add_branch(self.get_argument('branch'))
project.version(self.get_argument('branch'), self.get_argument('version'))
project.group_name = self.get_argument('group_name')
project.save()
log.msg('Project created:', project.name)
reactor.callInThread(queue.enqueue, 'build', 'builder.build_project', {'project': project.name, 'branch': self.get_argument('branch'), 'force': True})
self.write(cyclone.escape.json_encode({'status': 'ok'}))
except Exception, e:
log.err()
self.write(cyclone.escape.json_encode({'status': "fail"}))
class Builder:
def __init__(self, project):
self.workspace = BrickConfig().get('workspace', 'dir')
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.workdir = self.git.workdir
self.build_system = BrickConfig().get('build', 'system')
self.ftp_host = BrickConfig().get('ftp', 'host')
self.ftp_user = BrickConfig().get('ftp', 'user')
self.ftp_pass = BrickConfig().get('ftp', 'pass')
self.ftp_dir = BrickConfig().get('ftp', 'dir')
if self.build_system == 'rpm':
self.package_builder = RpmBuilder(self)
elif self.build_system == 'deb':
self.package_builder = DebBuilder(self)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}'
)
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp'
)
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def _exec(self, cmd, *args, **kwargs):
return subprocess.Popen(cmd, *args, **kwargs)
def build_project(self, force=False, a_branch=None):
try:
if force:
build = 1
else:
build = 0
"""
force build for a specific branch only if a_branch is not None
"""
if a_branch:
branches = [a_branch]
else:
branches = self.project.branches()
for branch in branches:
log.debug("Checking project: %s" % self.project.name)
try:
if not os.path.isdir(self.git.workdir):
self.git.clone(branch)
else:
self.git.checkout_tag(tag=".")
self.git.pull()
except Exception, e:
log.exception('Could not clone or update repository')
raise
if os.path.isdir(self.workdir):
os.chdir(self.workdir)
last_commit = self.git.last_commit(branch)
if self.project.last_commit(branch) != last_commit:
self.project.last_commit(branch, last_commit)
build = 1
self.project.save()
self.oldworkdir = self.workdir
if not os.path.isdir("%s-%s" % (self.workdir, branch)):
shutil.copytree(self.workdir, "%s-%s" % (self.workdir, branch))
self.workdir = "%s-%s" % (self.workdir, branch)
self.git.workdir = self.workdir
self.git.pull()
self.git.checkout_branch(branch)
if build == 1:
log.info('Generating packages for %s on %s' % (self.project, self.workdir))
self.package_builder.build(branch)
self.package_builder.upload(branch)
log.info("build complete")
self.workdir = self.oldworkdir
self.git.workdir = self.workdir
self.git.checkout_branch('master')
branch = 'master'
for tag_type in ('testing', 'stable'):
log.info('Last tag found: %s' % self.project.last_tag(tag_type))
if self.project.last_tag(tag_type) != self.git.last_tag(tag_type):
self.project.last_tag(tag_type, self.git.last_tag(tag_type))
if self.project.last_tag(tag_type):
self.git.checkout_tag(self.project.last_tag(tag_type))
self.package_builder.build(branch, self.project.last_tag(tag_type))
self.package_builder.upload(tag_type)
self.git.checkout_branch(branch)
except Exception, e:
log.exception("build failed: %s" % repr(e))
def delete(self, project_name):
project = Projects(project_name)
branch = self.get_argument('branch')
project.remove_branch(branch)
self.write(cyclone.escape.json_encode({'status': 'ok'}))
def post(self, *args):
if len(args) >= 1:
name = args[0]
project = Projects(name)
for key, value in self.request.arguments.iteritems():
if key in ("git_url", "version", "build_cmd", "install_cmd"):
setattr(project, key, value[0])
project.save()
try:
if not Projects(self.get_argument("name")).exists():
raise
except Exception, e:
project = Projects()
project.name = self.get_argument("name")[0]
project.git_url = self.get_argument("git_url")[0]
for name, parm in self.request.arguments.iteritems():
if name not in ("branch", "version"):
setattr(project, str(name), parm[0])
try:
project.add_branch(self.get_argument("branch"))
project.version(self.get_argument("branch"), self.get_argument("version"))
project.group_name = self.get_argument("group_name")
project.save()
log.msg("Project created:", project.name)
self.write(cyclone.escape.json_encode({"status": "ok"}))
except Exception, e:
log.err()
self.write(cyclone.escape.json_encode({"status": "fail"}))
def get(self, project_name):
project = Projects(project_name)
git = Git(project)
branches = git.branches(remote=True)
self.write(cyclone.escape.json_encode({'branches': branches}))
class Builder(object):
def __init__(self, project):
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.build_system = BrickConfig().get('build', 'system')
self.build_options = BuildOptions(self.git.workdir)
self.build_container = None
self.workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'),
self.project.name,
)
self.real_workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'), self.project.name
)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}'
)
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp'
)
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def _exec(self, cmd, *args, **kwargs):
if True or self.build_options.not_found:
return subprocess.Popen(cmd, *args, **kwargs)
else:
chroot_cmd = "chroot %s bash -c \"cd %s; %s\"" % (self.build_container.dir, self.real_workspace, " ".join(cmd))
kwargs.update({'shell': True})
return subprocess.Popen(chroot_cmd, *args, **kwargs)
def build_project(self, branch=None, release=None, version=None, commit=None):
if not self.project.is_building():
self.project.start_building()
try:
self.workdir = "%s-%s" % (self.git.workdir, release)
self.real_workspace = "%s-%s" % (self.real_workspace, release)
shutil.copytree(self.git.workdir, self.workdir)
if self.build_system == 'rpm':
self.package_builder = BuilderRpm(self)
elif self.build_system == 'deb':
self.package_builder = BuilderDeb(self)
os.chdir(self.workdir)
self.git.workdir = self.workdir
self.git.checkout_branch(branch)
if release == 'experimental' and self.build_options.changelog:
self.git.checkout_branch(branch)
self.package_builder.build(branch, release)
self.package_builder.upload(branch)
if release != None and commit != None:
self.git.checkout_tag(commit)
self.package_builder.build(branch, force_version=version, force_release=release)
self.package_builder.upload(release)
else:
self.project.last_tag(release, self.git.last_tag(release))
self.git.checkout_tag(self.project.last_tag(release))
self.package_builder.build(branch, self.project.last_tag(release))
self.package_builder.upload(release)
self.git.checkout_branch('master')
except Exception, e:
log.exception("build failed: %s" % repr(e))
finally:
class Builder(object):
def __init__(self, project):
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.build_system = BrickConfig().get('build', 'system')
self.build_options = BuildOptions(self.git.workdir)
self.build_container = None
self.workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'),
self.project.name,
)
self.real_workspace = "%s/%s" % (BrickConfig().get(
'workspace', 'dir'), self.project.name)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}')
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp')
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def _exec(self, cmd, *args, **kwargs):
if True or self.build_options.not_found:
return subprocess.Popen(cmd, *args, **kwargs)
else:
chroot_cmd = "chroot %s bash -c \"cd %s; %s\"" % (
self.build_container.dir, self.real_workspace, " ".join(cmd))
kwargs.update({'shell': True})
kwargs["cwd"] = self.workdir
return subprocess.Popen(chroot_cmd, *args, **kwargs)
def build_project(self,
branch=None,
release=None,
version=None,
commit=None):
if not self.project.is_building():
self.project.start_building()
try:
if (release is not None and version is not None):
if (not self.git.pull()):
self.git.clone(branch)
self.workdir = "%s-%s" % (self.git.workdir, release)
self.real_workspace = "%s-%s" % (self.real_workspace, release)
if (os.path.exists(self.workdir)):
shutil.rmtree(self.workdir, ignore_errors=True)
shutil.copytree(self.git.workdir, self.workdir)
if self.build_system == 'rpm':
self.package_builder = BuilderRpm(self)
elif self.build_system == 'deb':
self.package_builder = BuilderDeb(self)
# os.chdir(self.workdir)
self.git.workdir = self.workdir
self.git.checkout_branch(branch)
if release == 'experimental' and self.build_options.changelog:
self.git.checkout_branch(branch)
self.package_builder.build(branch, release)
self.package_builder.upload(branch)
if release != None and commit != None:
self.git.checkout_tag(commit)
self.package_builder.build(branch,
force_version=version,
force_release=release)
self.package_builder.upload(release)
else:
self.project.last_tag(release, self.git.last_tag(release))
self.git.checkout_tag(self.project.last_tag(release))
self.package_builder.build(branch,
self.project.last_tag(release))
self.package_builder.upload(release)
self.git.checkout_branch('master')
except Exception, e:
log.exception("build failed: %s" % repr(e))
finally:
class Builder(object):
def __init__(self, project):
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.build_system = BrickConfig().get('build', 'system')
self.build_options = BuildOptions(self.git.workdir)
self.build_container = None
self.workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'),
self.project.name,
)
self.real_workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'), self.project.name
)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}'
)
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp'
)
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def _exec(self, cmd, *args, **kwargs):
log.msg("[%s] exec: %s %s [%s]" % (self.project.name, cmd, args, kwargs))
return subprocess.Popen(cmd, *args, **kwargs)
def build_project(self, branch=None, release=None, version=None, commit=None):
if not self.project.is_building():
self.project.start_building()
try:
if (release is not None and version is not None):
log.msg("[%s] git fetch/clone" % (self.project.name,))
if (not self.git.pull()):
self.git.clone(branch)
self.workdir = "%s-%s" % (self.git.workdir, release)
self.real_workspace = "%s-%s" % (self.real_workspace, release)
if (os.path.exists(self.workdir)):
shutil.rmtree(self.workdir, ignore_errors=True)
shutil.copytree(self.git.workdir, self.workdir, True)
log.msg("[%s] shutil.copytree: ok" % (self.project.name,))
if self.build_system == 'rpm':
self.package_builder = BuilderRpm(self)
elif self.build_system == 'deb':
self.package_builder = BuilderDeb(self)
os.chdir(self.workdir)
self.git.workdir = self.workdir
self.git.checkout_branch(branch)
if release == 'experimental' and self.build_options.changelog:
self.git.checkout_branch(branch)
self.package_builder.build(branch, release)
self.package_builder.upload(branch)
if release != None and commit != None:
self.git.checkout_tag(commit)
self.package_builder.build(branch, force_version=version, force_release=release)
self.package_builder.upload(release)
else:
self.project.last_tag(release, self.git.last_tag(release))
self.git.checkout_tag(self.project.last_tag(release))
self.package_builder.build(branch, self.project.last_tag(release))
self.package_builder.upload(release)
self.git.checkout_branch('master')
except Exception, e:
log.msg("[%s] %s" % (self.project.name, traceback.format_exc()))
finally:
def delete(self, name):
try:
project = Projects(name)
project.delete()
except Exception, e:
log.err(e)
class SimBatch:
s = None
comfun = None
logger = None
os = None
def __init__(self, runtime_env, ini_file="config.ini", os=None):
self.logger = Logger(log_level=0, console_level=3)
self.sts = Settings(self.logger, runtime_env, ini_file=ini_file) # sts
self.logger.set_console_level(self.sts.debug_level)
self.logger.set_log_level(0)
self.comfun = CommonFunctions(self.logger)
if os is None:
self.os = platform.system()
if self.os == "Windows":
self.os = "w"
elif self.os == "Linux":
self.os = "l"
else:
self.os = None
# abbreviation for very often used variables, helping with identification the main modules
self.usr = Users(self) # usr
self.prj = Projects(self) # prj
self.sch = Schemas(self) # sch
self.tsk = Tasks(self) # tsk
self.que = Queue(self) # que
self.nod = SimNodes(self) # nod
self.dfn = Definitions(self) # dfn
self.sio = StorageInOut(self) # sio
# abbreviation END
self.logger.inf("SimBatch started")
def print_data(self):
self.prj.print_all()
def print_important_values(self):
print " \n\n Current runtime_env: {}", self.sts.runtime_env
# projects
print "\n PROJECTS: "
self.prj.print_current()
# schemas
print "\n SCHEMAS: "
self.sch.print_current()
# tasks
print "\n TASKS: "
self.tsk.print_current()
# queue
print "\n QUEUE: "
self.que.print_current()
# nodes
print "\n NODES: "
self.nod.print_current()
# nodes
print "\n DEFINITIONS: "
self.dfn.print_current()
print "\n\n"
def print_current_detailed_values(self, index):
print " \n\n"
if self.sts.ui_edition_mode == 0: # open source hide wizard tab
index += 1 # index compensation
if index == 0:
print " WIZARD: "
if index == 1:
self.prj.print_all()
self.prj.print_current()
if index == 2:
print " SCHEMAS: "
self.sch.print_all()
self.sch.print_current()
if index == 3:
print " TASKS: "
self.tsk.print_all()
self.tsk.print_current()
if index == 4:
print " QUEUE: "
self.que.print_all()
self.que.print_current()
# if index == 5:
# TODO NODES !!!!
# self.nod.print_all()
# self.nod.print_current()
if index == 5: # TODO NODES index 4 vs 5 !
print " SETTINGS: "
self.sts.print_all()
print "\n\n"
def clear_all_stored_data(self):
self.prj.clear_all_projects_data(clear_stored_data=True)
self.sch.clear_all_schemas_data(clear_stored_data=True)
def clear_all_memory_data(self):
self.prj.clear_all_projects_data()
self.sch.clear_all_schemas_data()
def loading_errors(self, check_this, counter, msg):
if self.comfun.is_int(check_this):
counter += check_this
self.logger.err(
"Loading error! File: ({}) file errors count:{}".format(
msg, check_this))
return counter
def load_data(self):
if self.sts.loading_state >= 3:
ret_def = self.dfn.load_definitions()
ret_prj = self.prj.load_projects()
if ret_prj is not False:
self.prj.init_default_proj()
ret_sch = self.sch.load_schemas()
if ret_sch is not False:
ret_tsk = self.tsk.load_tasks()
if ret_tsk is not False:
ret_que = self.que.load_queue()
if ret_que is not False:
ret_nod = self.nod.load_nodes()
if ret_tsk is not False:
loading_err_count = 0 # count number errors while of loading external data
loading_err_count = self.loading_errors(
ret_def, loading_err_count, "definitions")
loading_err_count = self.loading_errors(
ret_prj, loading_err_count, "project")
loading_err_count = self.loading_errors(
ret_sch, loading_err_count, "schemas")
loading_err_count = self.loading_errors(
ret_tsk, loading_err_count, "tasks")
if loading_err_count == 0:
return True
else:
return loading_err_count
else:
return -5
else:
return -4
else:
return -1
else:
return -2
else:
return -3
else:
return False
def create_example_data(self):
self.prj.create_example_project_data()
def get(self, project_name):
project = Projects(project_name)
branches = project.branches()
self.write(cyclone.escape.json_encode({'branches': branches}))
def post(self, project_name):
project = Projects(project_name)
builder = Builder(project_name)
builder.build_project()
def delete(self, project_name):
project = Projects(project_name)
branch = self.get_argument('branch')
project.remove_branch(branch)
self.write(cyclone.escape.json_encode({'status': 'ok'}))
def get(self, name="", branch="master"):
try:
if name:
project = Projects(name)
reply = {
"name": project.name,
"branch": project.branches(),
"experimental": int(project.experimental),
"group_name": project.group_name,
"git_url": project.git_url,
"version": project.version(),
"last_tag_testing": project.last_tag(tag_type="testing"),
"last_tag_stable": project.last_tag(tag_type="stable"),
"last_tag_unstable": project.last_tag(tag_type="unstable"),
"last_commit": project.last_commit(branch),
}
else:
projects = Projects.get_all()
reply = []
for project in projects:
reply.append(
{
"name": project.name,
"branch": project.branches(),
"experimental": int(project.experimental),
"group_name": project.group_name,
"git_url": project.git_url,
"version": project.version(),
"last_tag_testing": project.last_tag(tag_type="testing"),
"last_tag_stable": project.last_tag(tag_type="stable"),
"last_tag_unstable": project.last_tag(tag_type="unstable"),
"last_commit": project.last_commit(branch),
}
)
self.write(cyclone.escape.json_encode(reply))
except Exception, e:
self.write(cyclone.escape.json_encode("%s No project found" % e))
def get(self, name='', branch='master'):
try:
if name:
project = Projects(name)
reply = {'name': project.name,
'branch': project.branches(),
'group_name': project.group_name,
'git_url': project.git_url,
'version': project.version(),
'last_tag_testing': project.last_tag(tag_type='testing'),
'last_tag_stable': project.last_tag(tag_type='stable'),
'last_commit': project.last_commit(branch)}
else:
projects = Projects.get_all()
reply = []
for project in projects:
reply.append(
{'name': project.name,
'branch': project.branches(),
'group_name': project.group_name,
'git_url': project.git_url,
'version': project.version(),
'last_tag_testing': project.last_tag(tag_type='testing'),
'last_tag_stable': project.last_tag(tag_type='stable'),
'last_commit': project.last_commit(branch)
})
self.write(cyclone.escape.json_encode(reply))
except Exception, e:
self.write(cyclone.escape.json_encode("%s No project found" % e))
def delete(self, project_name):
project = Projects(project_name)
branch = self.get_argument("branch")
project.remove_branch(branch)
self.write(cyclone.escape.json_encode({"status": "ok"}))
usage()
try:
srcSys = opts['-s']
dstSys = opts['-d']
grpNam = opts['-g']
except KeyError:
usage()
# create a group itself
grp = Groups()
try:
srcGid = grp.by_name(srcSys, grpNam)['id']
except KeyError:
usage("Group with name '%s' doesn't exist in the source system" % grpNam)
dstGid = grp.add(dstSys, grpNam)['id']
# add members to the group
add_members(grp, srcGid, dstGid)
# copy projects with their members from the source group to the destination one
prj = Projects()
for p in prj.by_namespace(srcSys, srcGid):
add_members(prj, p['id'], prj.add(dstSys, p['name'], namespace_id = dstGid, **filter_dict(p,
'description',
'issues_enabled',
'merge_requests_enabled',
'wiki_enabled',
'snippets_enabled',
'visibility_level'))['id'])
import datetime
import calendar
import tkinter as tk
from tkinter import ttk
import hud as Hud
from customer import Customer
from database import Database
from projects import Projects
from tasks import Tasks
from tkcalendar import Calendar
from tkcalendar import DateEntry
current_customer = Customer('', '', '', '', '', '', '', '')
current_project = Projects('', '', '', '', '', '', '', '', '', '', '', '', '',
'', '')
current_task = Tasks('', '', '', '', '', '', '', '')
task_frame_count = []
LARGE_FONT = ('Verdaba', 12)
def convert_date_postgres(date_to_conv, I_or_O):
# if I prepare for input, if O prepare for output
if I_or_O.lower() == 'i':
year_to = date_to_conv[6:10]
month_to = date_to_conv[3:5]
day_to = date_to_conv[0:2]
iso = f'{year_to}-{month_to}-{day_to}'
return iso
if I_or_O.lower() == 'o':
