Plugins are Go’s system for developing shared-libraries. However, this is backed by a general system that can also have alternative implementations. In this case, you can write a plugin in Go that runs from one system and load that plugin in Go, on the fly, from a million other systems. Courtesy of Hashicorp.
https://github.com/hashicorp/go-plugin
argcomplete provides very useful functionality that you will basically get for free with just a couple of steps.
Put some markup below the shebang of your frontend script in the form of a comment:
#!/usr/bin/env python # PYTHON_ARGCOMPLETE_OK
The BASH-completion script argcomplete will basically identify and scan any script with a Python shebang that is used with BASH-completion. This entails actually running the script. In order to minimize how much time is spent loading scripts that don’t actually use argcomplete, the completion script will ignore anything that does not have this comment directly following the shebang.
Next, add and import for the argcomplete package and run argcomplete.autocomplete(parser) after you have configured your command-line parameters but before your call to parser.parse_args() (where parser is an instance of argparse.ArgumentParser). This function will produce command-line configuration metadata and then terminate.
That is it. Note that it is not practical to assume that everyone who uses your script will have argcomplete installed. They may not be using BASH (BASH is the only well-supported shell at this time), they may not be using a supported OS, and/or any commercial environments that adopt your tools may be server environments that have no use for command-line completion and refuse to support it. Therefore, you should wrap the import with a try-except for ImportError and then only call argcomplete.autocomplete if you were able to import the package.
To install autocomplete, the simplest route is to merely do a “sudo pip install argcomplete” and then call “activate-global-python-argcomplete” (this is a physical script likely installed to /usr/local/bin. This only has to be done once and will install a non-project-specific script that will work for any script that is equipped to use argcomplete. For other configuration and semantics, see the project page.
From back in 2005:
On the positive side, LLVM has a lot more experience in managing whole program compilation, and it is a much cleaner software base. It would be a good to find some mechanism to take advantage of that experience. Trying to make the hippo dance is not really a lot of fun.
A discussion of the plateauing of Moore’s Law, published back in 2005:
The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software
This might be necessary if you, for example, want to apply your own set of replacements to a string argument that will be passed to you by another mechanism that applies its own set of replacements.
This example supposes that you might want to use square-brackets instead of the standard curly-brackets.
import string
import re
_FIELD_RE = re.compile(r'\[([a-zA-Z0-9_]+)\]')
class CustomReplacer(string.Formatter):
def parse(self, s):
last_stop_index = None
for m in _FIELD_RE.finditer(s):
token_name = m.group(1)
start_index, stop_index = m.span()
if start_index == 0:
prefix_fragment = ''
elif last_stop_index is None:
prefix_fragment = s[:start_index]
else:
prefix_fragment = s[last_stop_index:start_index]
last_stop_index = stop_index
yield prefix_fragment, token_name, '', None
cr = CustomReplacer()
template = 'aa [name] bb [name2] cc dd [name3]'
replacements = {
'name': 'howard',
'name2': 'mark',
'name3': 'james',
}
output = cr.format(template, **replacements)
print(output)
Output:
aa howard bb mark cc dd james
Note that no formatting is supported with our custom replacer (though it could be added, with more work). If any formatting specifiers are provided, they will fail the regular-expression match and be ignored.
Use speedtest-cli:
$ curl -s https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py | python - Retrieving speedtest.net configuration... Testing from Comcast Cable (73.1.128.16)... Retrieving speedtest.net server list... Selecting best server based on ping... Hosted by Broadwave (Fort Lauderdale, FL) [43.78 km]: 22.155 ms Testing download speed................................................................................ Download: 232.72 Mbit/s Testing upload speed...................................................................................................... Upload: 10.07 Mbit/s
Installing the knockd daemon, and configuring the sequence and packet types to be used to open and close ports, and using the knock client to actually do it from the other side:
https://www.howtogeek.com/442733/how-to-use-port-knocking-on-linux-and-why-you-shouldnt/
Some plugins may extent the Jenkins API with additional functionality. To [blindly] determine if this is the case for a particular plugin of interest, first enumerate the list of installed plugins:
https://<jenkins server>/pluginManager/api/json?depth=2
Then, find the plugin in the list and get the value from its “shortName” field:
That value is the name used in the API URL. In this case, that URL would be https://<jenkins server>/gerrit-trigger. This might be enough to get you what you need, though, depending on the plugin, you might have to reverse-engineer the plugins’ sourcecode in order to find which further nouns/entity subpaths are available from here. You might do a Google search and then grep for the paths that you find from that in order to discover siblings.
This is not meant to be a complicated post, though the information is made complicated by the effort required to find the information.
I’m a Linux guy, but the lure of a new filesystem spec can not be denied.
This is a read-only exFAT impementation in pure Go. This provides a direct API, but several command-line tools were also made available with which to inspect the filesystem’s structure. There’s 90% test-coverage and an A+ on the score-card.
Random Engineering 
You must be logged in to post a comment.