bashed | Bash functions I wrote to automate workflows and make | Automation library

You can do it like this:

I got this working. The solution was a bit brute force — overloading the createRoute function. Here's what I have:

Passing it around as native size_t like a uint32. There is little room for error here. So I THINK this is safe, right? You need to be explicit about re-casting it when you want to use it.

No, neither size_t nor uint32_t is certain to be suitable for this purpose, even on 32-bit systems. The size of an address is not necessarily the same as or smaller than the size of a machine word -- if indeed that is indeed what a uint32_t represents in a given implementation -- and there is no guarantee that it will fit in a size_t either. If you want to pass addresses around in integer form then you should use intptr_t or uintptr_t (from stdint.h). If your implementation does not define these optional types then there might not be any integer type suitable for the purpose.

With that said, however, if you're trying to convey a pointer, then it's odd to propose conveying it other than as a pointer.

This does seem to be what void pointers are for. But the number of times I've been bashed in the head with "void pointers are bad" is not null. Is this unsafe in any way? Returning like this, I lose my ability to return errors other than success/failure by implying if ADDRESS is null or not.

It is what void pointers are for if there is no more suitable pointer type. If you will always be returning a pointer to a specific data type, on the other hand, then the pointer type should reflect that. There is nothing inherently unsafe with returning a pointer, target type notwithstanding.

If you need to provide finer-grained status information than success / failure, then you should use an out parameter in addition to the function's return value. It's your choice, then, whether the pointer or the status code is conveyed via that parameter.

I've no idea what misguided programming philosophy or coding convention might teach that use of type void * in C is unconditionally bad. There are definitely situations in which it is the right thing to do, and they're not all that rare.

Seems like a good spot for a double pointer. I have a guy that works under me and is just learning C, so I wasn't trying to confuse him just yet.

That would be the out parameter option already discussed. There's nothing particularly wrong with that, but if you can do without an out parameter by using the return value, then that's the way I would go, myself.

I know there is a ton of opinion on how this can be done. But is there anything factual in terms of safety or best practice?

I don't think there's much diversity of opinion about how it can be done. I'm disinclined to believe that many people would disagree that if you specifically want to convey a pointer then you would best do so as a pointer, or that you should prefer a more specific pointer type over void * where there is one that serves the purpose. Beyond that, I'd say the details are a matter of project convention, situation-specific requirements, and personal preference.

In k8s docs about pods you can read:

Pods in a Kubernetes cluster are used in two main ways:

• Pods that run a single container. [...]

• Pods that run multiple containers that need to work together. [...]

Note: Grouping multiple co-located and co-managed containers in a single Pod is a relatively advanced use case. You should use this pattern only in specific instances in which your containers are tightly coupled.

Each Pod is meant to run a single instance of a given application. [...]

Notice that your deployment doesn't fit this descriprion because you are trying to run two applications in one pod.

Remember to always use one pod per container and only use multiple containers per pod if it's impossible to separate them (and for some reason they have to run together).

And the rest was already mentioned by David.

store it in a variable and call

This context deadline exceeded generally happens because of

1. Using wrong certificates. You could be using peer certificates instead of client certificates. You need to check the Kubernetes API Server parameters which will tell you where are the client certificates located because Kubernetes API Server is a client to ETCD. Then you can use those same certificates in the etcdctl command from the node.

2. The etcd cluster is not operational anymore because peer members are down.

I believe your goal as follows.

• You want to retrieve the Google Document object as JSON data using the get method of Google Docs API.
• You want to achieve this using API key.
• You want to make users download the Google Document object using a single URL.
  • From I want my application to only see the single shared document URL.

For this, how about this answer?

In the current stage, it seems that the get method of Docs API cannot be used with the API key, even when the Google Document is publicly shared. When the get method of Docs API is requested to the publicly shared Google Document with the API key, the following value is returned. (In this case, it has already been confirmed that the API key can be used for Drive API.)

You are probably running your container as root user. Hence you do not have the permission to edit them via your editor.

Try running your container with a regular user (for example docker run --user 1000:1000 whatever-you-need).

Your problematic is quite interesting indeed. I gave it a shot but before I explain the solution, I'd like to pinpoint a few conceptual issues I saw during my work on your code. Here are the changes I made:

1. Your JSON structure is not quite easy to parse in my opinion. I opted for something a bit more comfortable by removing the "children" node since there are always only two possible choices: yes or no

2. Don't get confused: once loaded, a JSON message such as yours is nothing more than a simple dict with other dicts embedded. You don't need to write anything in the JSON file by yourself because Python knows how to translate such structures.

3. Using iteration in a tree hierarchy is known to be a bad choice in terms of performances and ease of use. Using recursion is much straighforward and I strongly encourage you to learn how it can be effective in some cases such as this one

4. I found the validation to be something like a side effect of your iterative process. You don't need that extra validation parameter everywhere in my opinion, but feel free to integrate it back when you'd really need it

5. I "optimized" your code by adding a few things such as the if __name__ == "__main__" which purpose is to check if the Python file is started as a module or is embedded in another solution. You also misused the open directive to read and write files. I fixed those for you

Hopefully you'll learn a few tricks by reading my solution, that's at least why I'm writing it. I do not pretend to know everything, so there might be mistakes as well but it should help you going forward with your project. I would typically expect you to split the learning part of the script into other functions.

The main script: