def openLogFd(self, opts): opath = self.locs.get('log:fp') if opath: self.printf( 'Must call --off to disable current file before starting a new file.' ) return fmt = opts.format path = opts.path nodes_only = opts.nodes_only edits_only = opts.edits_only if not path: ts = s_time.repr(s_common.now(), True) fn = f'storm_{ts}.{fmt}' path = s_common.getSynPath('stormlogs', fn) self.printf(f'Starting logfile at [{path}]') q = queue.Queue() fd = s_common.genfile(path) # Seek to the end of the file. Allows a user to append to a file. fd.seek(0, 2) self.locs['log:fp'] = path self.locs['log:fd'] = fd self.locs['log:fmt'] = fmt self.locs['log:queue'] = q self.locs['log:thr'] = self.queueLoop() self.locs['log:nodesonly'] = nodes_only self.locs['log:editsonly'] = edits_only self._cmd_cli.on('storm:mesg', self.onStormMesg)
def openLogFd(self, opts): opath = self.locs.get('log:fp') if opath: self.printf('Must call --off to disable current file before starting a new file.') return fmt = opts.format path = opts.path nodes_only = opts.nodes_only splice_only = opts.splices_only if not path: ts = s_time.repr(s_common.now(), True) fn = f'storm_{ts}.{fmt}' path = s_common.getSynPath('stormlogs', fn) self.printf(f'Starting logfile at [{path}]') q = queue.Queue() fd = s_common.genfile(path) # Seek to the end of the file. Allows a user to append to a file. fd.seek(0, 2) self.locs['log:fp'] = path self.locs['log:fd'] = fd self.locs['log:fmt'] = fmt self.locs['log:queue'] = q self.locs['log:thr'] = self.queueLoop() self.locs['log:nodesonly'] = nodes_only self.locs['log:splicesonly'] = splice_only self._cmd_cli.on('storm:mesg', self.onStormMesg)
async def main(argv, outp=s_output.stdout): pars = getArgParser() opts = pars.parse_args(argv) path = s_common.getSynPath('telepath.yaml') telefini = await s_telepath.loadTeleEnv(path) async with await s_telepath.openurl(opts.cortex) as proxy: if telefini is not None: proxy.onfini(telefini) async with await StormCli.anit(proxy, outp=outp, opts=opts) as cli: if opts.onecmd: await cli.runCmdLine(opts.onecmd) return # pragma: no cover cli.colorsenabled = True cli.printf(welcome) await cli.addSignalHandlers() await cli.runCmdLoop()
async def main(argv): # pragma: no cover if len(argv) not in (1, 2): print( 'usage: python -m synapse.tools.cmdr <url> [<single quoted command>]' ) return 1 s_common.setlogging(logger, 'WARNING') path = s_common.getSynPath('telepath.yaml') telefini = await s_telepath.loadTeleEnv(path) # Ensure that SYN_DIR is available _ = s_common.getSynDir() async with await s_telepath.openurl(argv[0]) as item: try: s_version.reqVersion(item._getSynVers(), reqver) except s_exc.BadVersion as e: valu = s_version.fmtVersion(*e.get('valu')) print( f'Proxy version {valu} is outside of the cmdr supported range ({reqver}).' ) print( f'Please use a version of Synapse which supports {valu}; current version is {s_version.verstring}.' ) return 1 await runcmdr(argv, item) if telefini is not None: await telefini() return 0
async def prompt(self, text=None): ''' Prompt for user input from stdin. ''' if self.sess is None: hist = FileHistory(s_common.getSynPath('cmdr_history')) self.sess = PromptSession(history=hist) if text is None: text = self.cmdprompt with patch_stdout(): retn = await self.sess.prompt(text, async_=True, vi_mode=self.vi_mode, enable_open_in_editor=True) return retn
async def prompt(self, text=None): ''' Prompt for user input from stdin. ''' if self.sess is None: hist = FileHistory(s_common.getSynPath('cmdr_history')) self.sess = PromptSession(history=hist) if text is None: text = self.cmdprompt with patch_stdout(): retn = await self.sess.prompt_async(text, vi_mode=self.vi_mode, enable_open_in_editor=True) return retn
async def main(argv, outp=None): pars = setup() opts = pars.parse_args(argv) path = s_common.getSynPath('telepath.yaml') telefini = await s_telepath.loadTeleEnv(path) if outp is None: # pragma: no cover outp = s_output.OutPut() if opts.output is None: opts.output = '.' outdir = pathlib.Path(opts.output) s_common.gendir(opts.output) async with await s_telepath.openurl(opts.axon) as axon: # reminder: these are the hashes *not* available awants = await axon.wants([s_common.uhex(h) for h in opts.hashes]) for a in awants: outp.printf(f'{s_common.ehex(a)} not in axon store') exists = [h for h in opts.hashes if s_common.uhex(h) not in awants] for h in exists: try: outp.printf(f'Fetching {h} to file') with open(outdir.joinpath(h), 'wb') as fd: async for b in axon.get(s_common.uhex(h)): fd.write(b) outp.printf(f'Fetched {h} to file') except Exception as e: outp.printf('Error: Hit Exception: %s' % (str(e), )) continue if telefini: # pragma: no cover await telefini() return 0
async def main(argv, outp=None): # pragma: no cover if outp is None: outp = s_output.stdout s_common.setlogging(logger, 'WARNING') path = s_common.getSynPath('telepath.yaml') async with contextlib.AsyncExitStack() as ctx: telefini = await s_telepath.loadTeleEnv(path) if telefini is not None: ctx.push_async_callback(telefini) await _main(argv, outp) return 0
async def main(argv): # pragma: no cover if len(argv) not in (1, 2): print( 'usage: python -m synapse.tools.cmdr <url> [<single quoted command>]' ) return 1 s_common.setlogging(logger, 'WARNING') path = s_common.getSynPath('telepath.yaml') async with contextlib.AsyncExitStack() as ctx: telefini = await s_telepath.loadTeleEnv(path) if telefini is not None: ctx.push_async_callback(telefini) await _main(argv) return 0
async def main(argv, outp=None): # pragma: no cover if outp is None: outp = s_output.stdout if len(argv) not in (1, 2): outp.printf('usage: python -m synapse.tools.aha.list <url> [network name]') return 1 s_common.setlogging(logger, 'WARNING') path = s_common.getSynPath('telepath.yaml') async with contextlib.AsyncExitStack() as ctx: telefini = await s_telepath.loadTeleEnv(path) if telefini is not None: ctx.push_async_callback(telefini) await _main(argv, outp) return 0
def alias(name): ''' Resolve a telepath alias via ~/.syn/aliases.yaml Args: name (str): Name of the alias to resolve. Notes: An exact match against the aliases will always be returned first. If no exact match is found and the name contains a '/' in it, the value before the slash is looked up and the remainder of the path is joined to any result. This is done to support dynamic Telepath share names. Returns: str: The url string, if present in the alias. None will be returned if there are no matches. ''' path = s_common.getSynPath('aliases.yaml') if not os.path.isfile(path): return None conf = s_common.yamlload(path) # Is there an exact match - if so, return it. url = conf.get(name) if url: return url # Since telepath supports dynamic shared object access, # slice a name at the first '/', look up using that value # and then append the second value to it. dynname = None if '/' in name: name, dynname = name.split('/', 1) url = conf.get(name) if url and dynname: url = '/'.join([url, dynname]) return url
def alias(name): ''' Resolve a telepath alias via ~/.syn/aliases.yaml Args: name (str): Name of the alias to resolve. Notes: An exact match against the aliases will always be returned first. If no exact match is found and the name contains a '/' in it, the value before the slash is looked up and the remainder of the path is joined to any result. This is done to support dynamic Telepath share names. Returns: str: The url string, if present in the alias. None will be returned if there are no matches. ''' path = s_common.getSynPath('aliases.yaml') if not os.path.isfile(path): return None conf = s_common.yamlload(path) # Is there an exact match - if so, return it. url = conf.get(name) if url: return url # Since telepath supports dynamic shared object access, # slice a name at the first '/', look up using that value # and then append the second value to it. dynname = None if '/' in name: name, dynname = name.split('/', 1) url = conf.get(name) if url and dynname: url = '/'.join([url, dynname]) return url
async def main(argv, outprint=None): if outprint is None: # pragma: no cover outprint = s_output.OutPut() global outp outp = outprint async with contextlib.AsyncExitStack() as cm: teleyaml = s_common.getSynPath('telepath.yaml') if os.path.isfile(teleyaml): fini = await s_telepath.loadTeleEnv(teleyaml) cm.push_async_callback(fini) pars = makeargparser() try: opts = pars.parse_args(argv) except s_exc.ParserExit: return -1 retn = await opts.func(opts) return retn
async def test_alias(self): item = TeleAware() name = 'item' async with self.getTestDmon() as dmon: host, port = dmon.addr dmon.share(name, item) with self.getTestDir() as dirn: url = f'tcp://{host}:{port}/{name}' beepbeep_alias = url + '/beepbeep' aliases = {name: url, f'{name}/borp': beepbeep_alias} with self.setSynDir(dirn): fp = s_common.getSynPath('aliases.yaml') s_common.yamlsave(aliases, fp) # None existent aliases return None self.none(s_telepath.alias('newp')) self.none(s_telepath.alias('newp/path')) # An exact match wins self.eq(s_telepath.alias(name), url) self.eq(s_telepath.alias(f'{name}/borp'), beepbeep_alias) # Dynamic aliases are valid. self.eq(s_telepath.alias(f'{name}/beepbeep'), beepbeep_alias) async with await s_telepath.openurl(name) as prox: self.eq(10, await prox.getFooBar(20, 10)) # Check to see that we can connect to an aliased name # with a dynamic share attached to it. async with await s_telepath.openurl(f'{name}/bar') as prox: self.eq('bar: beep', await prox.beep())
async def main(argv, outp=None): if outp is None: # pragma: no cover outp = s_output.OutPut() path = s_common.getSynPath('telepath.yaml') telefini = await s_telepath.loadTeleEnv(path) pars = makeargparser() opts = pars.parse_args(argv) axon = await s_telepath.openurl(opts.axon) core = None if opts.cortex: core = await s_telepath.openurl(opts.cortex) tags = set() if opts.tags: for tag in opts.tags.split(','): tags.add(tag) tags = tuple(tags) if tags: outp.printf(f'adding tags: {tags}') filepaths = set() for item in opts.filenames: paths = glob.glob(item, recursive=opts.recursive) if not paths: outp.printf(f'filepath does not contain any files: {item}') continue filepaths.update([path for path in paths if os.path.isfile(path)]) for path in filepaths: bname = os.path.basename(path) hset = s_hashset.HashSet() with s_common.reqfile(path) as fd: hset.eatfd(fd) fhashes = {htyp: hasher.hexdigest() for htyp, hasher in hset.hashes} sha256 = fhashes.get('sha256') bsha256 = s_common.uhex(sha256) if not await axon.has(bsha256): async with await axon.upload() as upfd: with s_common.genfile(path) as fd: for byts in s_common.iterfd(fd): await upfd.write(byts) size, hashval = await upfd.save() if hashval != bsha256: # pragma: no cover raise s_exc.SynErr(mesg='hashes do not match', ehash=s_common.ehex(hashval), ahash=hashval) outp.printf(f'Uploaded [{bname}] to axon') else: outp.printf(f'Axon already had [{bname}]') if core: opts = { 'vars': { 'md5': fhashes.get('md5'), 'sha1': fhashes.get('sha1'), 'sha256': fhashes.get('sha256'), 'size': hset.size, 'name': bname, 'tags': tags, } } q = '[file:bytes=$sha256 :md5=$md5 :sha1=$sha1 :size=$size :name=$name] ' \ '{ for $tag in $tags { [+#$tag] } }' msgs = await core.storm(q, opts=opts).list() node = [m[1] for m in msgs if m[0] == 'node'][0] iden = node[0][1] size = node[1]['props']['size'] name = node[1]['props']['name'] mesg = f'file: {bname} ({size}) added to core ({iden}) as {name}' outp.printf(mesg) await axon.fini() if core: await core.fini() if telefini: # pragma: no cover await telefini() return 0