def _test_populate(self): from uuid import uuid1 as uuidgen once = datetime.utcnow() def minutes_td(minutes): return timedelta(minutes=minutes) # assert(hasattr(self, '_track_order')) self._span = Span(once - minutes_td(10), minutes_td(30)) track0 = QTrackItem(self, self.coords, 'IMAGE:test::timeline:GOES-21:QBI:mars', 1, "G21 QBI B99 BT", "test track", tooltip="peremptorily cromulent") # scene.addItem(abitrack) # done in init frame01 = QFrameItem(track0, self.coords, uuidgen(), once + minutes_td(5), minutes_td(5), Flags([VisualState.BUSY]), "abi1", "fulldiskimus") track1 = QTrackItem(self, self.coords, 'IMAGE:test::timeline:Himawari-11:AHI:mars', 0, "H11 AHI B99 Rad", "second test track", tooltip="nominally cromulent") frame11 = QFrameItem(track1, self.coords, uuidgen(), once + minutes_td(6), minutes_td(1), Flags([VisualState.READY]), "ahi1", "JP04") # self.insert_track(track0) # self.insert_track(track1) # assert(hasattr(self, '_propagate_max_z')) self.propagate_max_z() for track in [track0, track1]: track.update_pos_bounds() track.update_frame_positions() # scene.addItem(frame1) # done in init # blabla = QGraphicsTextItem('abcdcba') # font = QFont('White Rabbit') # blabla.setFont(font) # blabla.setPos(140, 100) # self.addItem(blabla) # blabla = None self.content = [track0, frame01, track1, frame11]
def test_lsblk_read(self): session = self.SessionFactory() writer = job_exec.job_exec() new_uuid1 = str(uuidgen()) new_uuid2 = str(uuidgen()) new_uuid3 = str(uuidgen()) writer.job_class = "lsblk_query" writer.cmdln = "lsblk --output %s --pairs" % ( ",".join(lsblk_wantedFields) ) writer.save( uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters="", uuid_job_def="", session=session, ) reader = job_exec.job_exec() reader.job_class = "lsblk_query" reader.cmdln = "" reader.save( uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters="", uuid_job_def="", session=session, ) new = job_exec.job_exec()
def test_session_set(self): session = self.SessionFactory() new = job_exec.job_exec(session = session) new.session = session new_uuid1 = str(uuidgen()) new_uuid2 = str(uuidgen()) new_uuid3 = str(uuidgen()) new.job_class = "lsblk_query" self.assertTrue(new.job_class == "lsblk_query") new.save( session=session, uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters="", uuid_job_def="", )
def setUp(self): self.log = logging.getLogger("TestJobManager") f = tempfile.NamedTemporaryFile(delete=False) databaseConnectionString = "sqlite:///%s" % (f.name) self.engine = create_engine(databaseConnectionString, echo=False) model.init(self.engine) self.SessionFactory = sessionmaker(bind=self.engine) devices.initial_data_add_enumerated(self.SessionFactory()) session = self.SessionFactory() jobmanager = job_manage.job_manage() jobmanager.session = session jobmanager.create_job_class(name = "lsblk_query") jobmanager.create_job_class(name = "lsblk_read") self.jobmanager_uuid1 = str(uuidgen()) self.jobmanager_uuid2 = str(uuidgen()) self.jobmanager_uuid3 = str(uuidgen()) rc1 = jobmanager.create_job_def( uuid=self.jobmanager_uuid1, job_class = "lsblk_read", cmdln_template = "ls", reocuring = 1, ) rc2 = jobmanager.create_job_def( uuid=self.jobmanager_uuid2, job_class = "lsblk_query", cmdln_template = "ls", reocuring = 1, ) job_details1 = jobmanager.get_job_def( uuid = self.jobmanager_uuid1, session =session, ) job_details2 = jobmanager.get_job_def( uuid = self.jobmanager_uuid1, session =session, ) job_details1.save() job_details2.save()
def _add_token(self, token): """Adds a token to the cache and writes cache to disk. cache_lock may not be held by anyone. :param token: Dict of the token to be added to the cache """ uuid = uuidgen().hex self.debug('Adding token %s to cache', uuid) with self._cache_lock: self.__refresh_cache() self._cache[uuid] = token self.__write_cache() return uuid
def new(self, title, draft=False): """ Create a new Post… """ self.title = title self.filename = newfile(slugify(self.title), draft) self.guid = str(uuidgen()) self.author = self.blog.config['blog']['defaultauthor'] self.categories = self.blog.config['blog']['categories'] self.updated = self.date self.permalink = '{}/{}/{}'.format(self.blog.config['blog']['url'], self.date.strftime('%Y/%m/%d'), slugify(self.title)) self.save() return self.filename
def post(self, _): uuid = str(uuidgen()) return self._create(None, uuid)
def _post_md5_task(): js = { 'id': str(uuidgen()), 'b': [content_maker.next() for _ in range(100)] } return Response(json.dumps(js), status=200, mimetype='application/json')
def save(self, *args, **kwargs): session = kwargs.get('session', None) if session == None: session = self.session if session == None: raise InputError("No session set") uuid_save = kwargs.get('uuid', None) if uuid_save == None: uuid_save = self.uuid if uuid_save == None: raise InputError("No uuid set") cmdln_template = kwargs.get('cmdln_template', None) if cmdln_template == None: cmdln_template = self.cmdln_template if cmdln_template == None: raise InputError("No cmdln_template set") session = kwargs.get('session', None) if session == None: session = self.session if session == None: sdsdfsdfs self.log.error("No session set") return False job_class = kwargs.get('job_class', None) if job_class == None: job_class = self.job_class if job_class == None: self.log.error("No job_class set") return False # Finished input validation query_job_namespace = session.query(model.job_namespace).\ filter(model.job_namespace.name == job_class) if query_job_namespace.count() == 0: job_namespace = model.job_namespace() job_namespace.name = job_class session.add(job_namespace) session.commit() query_job_namespace = session.query(model.job_namespace).\ filter(model.job_namespace.name == job_class) job_namespace = query_job_namespace.one() query_job_def = session.query(model.job_def).\ filter(model.job_def.uuid_job_def == uuid_save) if query_job_def.count() == 0: job_def = model.job_def() job_def.fk_type = job_namespace.id job_def.cmdln_template = self.cmdln_template job_def.cmdln_paramters = self.cmdln_paramters job_def.reocuring = self.reocuring job_def.uuid_job_def = uuid_save session.add(job_def) session.commit() query_job_def = session.query(model.job_def).\ filter(model.job_def.uuid_job_def == uuid_save) job_def = query_job_def.one() job_def.cmdln_template = self.cmdln_template job_def.cmdln_paramters = self.cmdln_paramters job_def.reocuring = self.reocuring job_def.fk_type = job_namespace.id session.add(job_def) session.commit() # Define sets of source and dest subscribers_found = set() publishers_found = set() source_job = aliased(model.job_def, name='source_job') dest_job = aliased(model.job_def, name='dest_job') query_subscribers = session.query(dest_job).\ filter(source_job.uuid_job_def == uuid_save).\ filter(model.job_triggers.dest == dest_job.id).\ filter(model.job_triggers.source == source_job.id) for item in query_subscribers: subscribers_found.add(item.uuid_job_def) query_publishers = session.query(source_job.uuid_job_def).\ filter(dest_job.uuid_job_def == uuid_save).\ filter(model.job_triggers.dest == dest_job.id).\ filter(model.job_triggers.source == source_job.id) for item in query_publishers: publishers_found.add(item.uuid_job_def) subscribers_missing = self.subscribe_list.difference(subscribers_found) publishers_missing = self.publish_list.difference(subscribers_found) subscribers_extra = subscribers_found.difference(self.subscribe_list) publishers_extra= subscribers_found.difference(self.publish_list) self.log.debug("subscribers_missing=%s" % (subscribers_missing)) for item in subscribers_missing: query_new = session.query(model.job_def).\ filter(model.job_def.uuid_job_def == item) for item in query_new: newtrigger = model.job_triggers() newtrigger.source = item.id newtrigger.dest = job_def.id newtrigger.sk_uuid = str(uuidgen()) session.add(newtrigger) session.commit() self.log.debug("publishers_missing=%s" % (publishers_missing)) for item in publishers_missing: query_new = session.query(model.job_def).\ filter(model.job_def.uuid_job_def == item) for item in query_new: newtrigger = model.job_triggers() newtrigger.source = job_def.id newtrigger.sk_uuid = str(uuidgen()) newtrigger.dest = item.id session.add(newtrigger) session.commit() self.log.debug("subscribers_extra=%s" % (subscribers_extra)) self.log.debug("publishers_extra=%s" % (publishers_extra))
def __init__(self, name): self.party_name = name self.players = set() self.game_over = False self.currently_playing = "" self.uuid = uuidgen()
"0.0.0.0" }) # Check if network metadata is not skipped if len(network_data) > 0: with open(net_file_path, 'w') as net_file: json_dump(network_data, net_file) generate_iso(cfg_file_path, cfg_dir_path, args.quiet) if args.clean_up: xprint("Cleaning up working dir.") rmtree(cfg_dir_path) if __name__ == '__main__': uuid = str(uuidgen()) parser = argparse.ArgumentParser( description='Config drive generator for MCP instances.', prog=argv[0], usage='%(prog)s [options]') parser.add_argument( '--gpg-key', type=str, help= 'Upload gpg key for salt master. Specify path to file in asc format.', required=False) parser.add_argument( '--name', type=str, default=uuid, help='Specify instance name. Hostname in short format, without domain.',
def dosync(configs): """ :param configs: :return: """ bkupsrc = """%s:""" % configs['host'] if configs['host'] else '' bkupsrc += """%s""" % os.path.join(configs['src-dir'], '').replace( ' ', '\ ') bkupdst = configs['dst-dir'] today = datetime.datetime.now().strftime("%Y-%m-%d") uuid = uuidgen() """ check command """ cmd_rsync_r = CMD_RSYNC if not configs[ 'asroot'] else CMD_SUDO + " " + CMD_RSYNC if not is_executable(CMD_RSYNC): print("command not found 'rsync', please install it.") print("sudo apt-get install -y rsync") if configs['asroot'] and not is_executable(CMD_SUDO): print("command not found 'sudo', please install it.") print("sudo apt-get install -y sudo") """ check directory """ if not os.path.isdir(configs['dst-dir']): if not os.path.isfile(configs['dst-dir']): print("Destination directory does not directory. please check it") return print("Destination directory does not existed. create it") if sys.version_info[0] < 3: makedirs(configs['dst-dir']) else: makedirs(configs['dst-dir']) """ Change Current Working Directory """ os.chdir(configs['dst-dir']) rsync_opts = """ -apvz """ if not configs['keep']: rsync_opts += """ --delete """ if configs['proto'] == 'ssh': if configs['password']: rshopts = " /usr/bin/sshpass -p %s ssh %s " % (configs['password'], configs['rsh-opts']) else: rshopts = " ssh %s " % configs['rsh-opts'] if configs['username']: rshopts += " -l %s " % configs['username'] if configs['port'] is not 22: rshopts += " -p %d " % configs['port'] rsync_opts += """ -e "%s" """ % rshopts rsync_opts += """ --rsync-path="%s" """ % cmd_rsync_r rsync_opts += """ --numeric-ids """ if configs['inc-backup']: logdir = "%s/%s" % (configs['dst-dir'], today) bkupname = str(uuid) else: logdir = configs['dst-dir'] + "/../Log" bkupname = os.path.basename(configs['dst-dir']) makedirs(logdir) logpath = os.path.join(logdir, bkupname + "-" + today + ".log") # print(logpath) logfile = open(logpath, 'w') # set bufsize to 0 logfile.write(str(datetime.datetime.now()) + '\n') """ sync .backupman.excludes """ rsync_excl_opts = """ --delete --include "%s" --exclude="*" """ % EXCLUDES try: rsync(bkupsrc, bkupdst, rsync_opts + rsync_excl_opts, logfile) except Exception: print( "Error during backup process. please see more details inside log file `%s`" % logpath) return """ sync """ if configs['inc-backup']: bkupdst = configs['dst-dir'] + "/" + today + "/" + str(uuid) makedirs(bkupdst) """ If .backupman.excludes is existed, append --exclude-from option """ excloc = os.path.join(configs['dst-dir'], EXCLUDES) if os.path.isfile(excloc): rsync_opts += """ --exclude-from "%s" """ % excloc try: rsync(bkupsrc, bkupdst, rsync_opts, logfile, verbose=True) except Exception: print( "Error during backup process. please see more details inside log file `%s`" % logpath) return if not configs['inc-backup']: return lastest = os.path.join(configs['dst-dir'], 'lastest') if os.path.exists(lastest): if not os.path.islink(lastest): print("`%s` is not link. can't create lastest link." % lastest) return else: os.remove(lastest) os.symlink(os.path.relpath(bkupdst, configs['dst-dir']), lastest)
def test_satpy_importer_basic(tmpdir, monkeypatch, mocker): """Basic import test using Satpy.""" from uwsift.workspace import Workspace from uwsift.model.layer import DocBasicLayer from uuid import uuid1 as uuidgen ws = Workspace(str(tmpdir)) c01_attrs = { Info.SHORT_NAME: 'C01', Info.DATASET_NAME: 'C01', Info.CENTRAL_WAVELENGTH: 2.0, Info.UUID: uuidgen(), } c03_attrs = { Info.SHORT_NAME: 'C03', Info.DATASET_NAME: 'C03', Info.CENTRAL_WAVELENGTH: 4.0, Info.UUID: uuidgen(), } doc = mocker.MagicMock() for ds in [c01_attrs, c03_attrs]: ds[Info.ORIGIN_X] = -5434894.885056 ds[Info.ORIGIN_Y] = 5434894.885056 ds[Info.CELL_HEIGHT] = 1000.0 ds[Info.CELL_WIDTH] = 1000.0 ds[Info.STANDARD_NAME] = "toa_bidirectional_reflectance" ds[Info.VALID_RANGE] = (0, 120) ds[Info.SCHED_TIME] = ds[Info.OBS_TIME] = datetime( 2018, 9, 10, 17, 0, 31, 100000) ds[Info.SHAPE] = (2, 2) ds[Info.PROJ] = "+proj=merc" ds[Info.FAMILY] = "family" ds[Info.CATEGORY] = "category" ds[Info.SERIAL] = "serial" ds[Info.PLATFORM] = Platform.GOES_16 ds[Info.INSTRUMENT] = Instrument.ABI c01 = DocBasicLayer(doc, c01_attrs) c03 = DocBasicLayer(doc, c03_attrs) ops = "z = x - y" ns = {'y': c03_attrs[Info.UUID], 'x': c01_attrs[Info.UUID]} def get_metadata(u): return c01 if u == c01_attrs[Info.UUID] else c03 def get_content(u): return np.ones((2, 2)) if u == c01_attrs[Info.UUID] else np.zeros( (2, 2)) monkeypatch.setattr(ws, 'get_metadata', get_metadata) monkeypatch.setattr(ws, 'get_content', get_content) uuid, info, data = ws.create_algebraic_composite(ops, ns, info={ Info.SHORT_NAME: 'new', Info.DATASET_NAME: 'new' }) np.testing.assert_equal(data, 1) assert info.get(Info.STANDARD_NAME) == "unknown"
def init_blockdevice_scan(session): log = logging.getLogger("init_blockdevice_scan") BlockUpdateLsblk_count = session.query(model.BlockUpdateLsblk).count() if BlockUpdateLsblk_count > 0: return writer = job_exec.job_exec() writer.session = session new_uuid1 = str(uuidgen()) new_uuid2 = str(uuidgen()) new_uuid3 = str(uuidgen()) writer.job_class = "lsblk_query" writer.cmdln = "lsblk --output %s --pairs" % ( ",".join(lsblk_wantedFields) ) writer.save( session=session, uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters="", uuid_job_def="", ) writer.run() reader = job_exec.job_exec() reader.session = session reader.job_class = "lsblk_read" reader.cmdln = "" reader.save( session=session, uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters=writer.outputjson, uuid_job_def="", ) reader.inputjson = writer.outputjson reader.run() if reader.outputjson == None: return json_copntent = json.loads(reader.outputjson) for item in json_copntent: job_query_udev = job_exec.job_exec() job_query_udev.session = session job_query_udev.job_class = "udev_query" job_query_udev.cmdln = item["cmdln"] job_query_udev.save( session=session, uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters=writer.outputjson, uuid_job_def="", ) job_query_udev.run() job_read_udev = job_exec.job_exec() job_read_udev.session = session job_read_udev.job_class = "udev_read" job_read_udev.save( session=session, uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters="", uuid_job_def="", ) job_read_udev.inputjson = job_query_udev.outputjson job_read_udev.run() job_mount_query = job_exec.job_exec() job_mount_query.session = session job_mount_query.job_class = "mount_query" job_mount_query.save( session=session, uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters="", uuid_job_def="", ) job_mount_query.inputjson = job_query_udev.outputjson job_mount_query.run() job_mount_read = job_exec.job_exec() job_mount_read.session = session job_mount_read.job_class = "mount_read" job_mount_read.save( session=session, uuid_tempate=new_uuid1, uuid_execution=new_uuid2, cmdln_template=new_uuid3, cmdln_paramters="", uuid_job_def="", ) job_mount_read.inputjson = job_mount_query.outputjson job_mount_read.run()