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 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':