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.
@plzasm
This is invaluable if you run into insidious little problems in servers or automated processes that run in Docker.
docker exec -it <container name> <command>
This can even be an interactive process, such as a shell.
The SeekableBuffer type is similar to a bytes.Buffer in that you can perform both reads and writes against it, but has the following two main differences:
bytes.Buffer.Eccentric usage of seek, read, and write behavior, such as the following, will work as expected:
Usage (from the unit-tests):
sb := NewSeekableBuffer()
// Write first string.
data := []byte("word1-word2")
_, err := sb.Write(data)
log.PanicIf(err)
// Seek and replace partway through, and replace more data than we
// currently have.
_, err = sb.Seek(6, os.SEEK_SET)
log.PanicIf(err)
data2 := []byte("word3-word4")
_, err = sb.Write(data2)
log.PanicIf(err)
// Read contents.
_, err = sb.Seek(0, os.SEEK_SET)
log.PanicIf(err)
buffer := make([]byte, 20)
_, err = sb.Read(buffer)
log.PanicIf(err)
// `buffer` currently has "word1-word3-word4".
A new project to recursively scan through a tree of images and determine which were captured as part of an auto-bracketing image capture operation.
Example:
$ bif_find tests/assets/images --json
[
{
"entries": [
{
"exposure_value": 0.0,
"rel_filepath": "DSC08196.JPG",
"timestamp": "2019-02-13T00:31:50"
},
{
"exposure_value": -0.7,
"rel_filepath": "DSC08197.JPG",
"timestamp": "2019-02-13T00:31:50"
},
{
"exposure_value": 0.7,
"rel_filepath": "DSC08198.JPG",
"timestamp": "2019-02-13T00:31:50"
},
{
"exposure_value": -1.3,
"rel_filepath": "DSC08199.JPG",
"timestamp": "2019-02-13T00:31:50"
},
{
"exposure_value": 1.3,
"rel_filepath": "DSC08200.JPG",
"timestamp": "2019-02-13T00:31:51"
}
],
"type": "periodic"
},
{
"entries": [
{
"exposure_value": 0.0,
"rel_filepath": "DSC08201.JPG",
"timestamp": "2019-02-13T00:32:09"
},
{
"exposure_value": -0.7,
"rel_filepath": "DSC08202.JPG",
"timestamp": "2019-02-13T00:32:09"
},
{
"exposure_value": 0.7,
"rel_filepath": "DSC08203.JPG",
"timestamp": "2019-02-13T00:32:10"
},
{
"exposure_value": -1.3,
"rel_filepath": "DSC08204.JPG",
"timestamp": "2019-02-13T00:32:10"
},
{
"exposure_value": 1.3,
"rel_filepath": "DSC08205.JPG",
"timestamp": "2019-02-13T00:32:10"
}
],
"type": "periodic"
}
]
By default, Python’s built-in ElementTree module strips comments as it reads them. The solution is just obscure enough to be hard to find.
import xml.etree.ElementTree as ET
class _CommentedTreeBuilder(ET.TreeBuilder):
def comment(self, data):
self.start('!comment', {})
self.data(data)
self.end('!comment')
def parse(filepath):
ctb = _CommentedTreeBuilder()
xp = ET.XMLParser(target=ctb)
tree = ET.parse(filepath, parser=xp)
root = tree.getroot()
# ...
When enumerating the parsed nodes, the comments will have a tag-name of “!comment”.
You may be in a situation where something else produces the sockets for you (such as an event-loop) or you otherwise need to manage the socket rather then allowing something else to.
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <openssl/ssl.h>
int main(int argc, char *argv[])
{
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (!sockfd) {
printf("Error creating socket.\n");
return -1;
}
struct sockaddr_in sa;
memset (&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr("172.217.2.196");
sa.sin_port = htons (443);
socklen_t socklen = sizeof(sa);
if (connect(sockfd, (struct sockaddr *)&sa, socklen)) {
printf("Error connecting to server.\n");
return -1;
}
SSL_library_init();
SSLeay_add_ssl_algorithms();
SSL_load_error_strings();
const SSL_METHOD *meth = TLSv1_2_client_method();
SSL_CTX *ctx = SSL_CTX_new (meth);
SSL *ssl = SSL_new (ctx);
if (ssl == NULL) {
printf("Could not create SSL context.\n");
return -1;
}
SSL_set_fd(ssl, sockfd);
int err = SSL_connect(ssl);
if (err <= 0) {
printf("Could not connect.\n");
return -1;
}
printf ("SSL connection using %s\n", SSL_get_cipher (ssl));
// Do send/receive here.
return 0;
}
Adapted from openssl-in-c-socket-connection-https-client, and works with both OpenSSL and BoringSSL.
go-github-reminders is a project that you can schedule in order to receive periodic emails of recently updated Github issues that you are involved in (technically, subscribed to) that you have not recently responded to.
For those of us with a lot to do, this keeps us on top of things.
