subsystems | making bioinformatics work with the SEED subsystems database | FTP library

AFAICT it is correctly set-up and both files above are considered in the hierarchy for node agent01.

You need to appreciate that Hiera is a flat key / value store that happens to support values with structured types. The key / subkey syntax that you demonstrate using with the lookup interpolation function might lead a person to mistake the data model for some kind of tree, but such a view leads to incorrect expectations.

In this case, the Hiera data presented defines two values for key my. The structure of those values is an altogether secondary consideration. You having not overridden the default lookup strategy for that key, you get a priority lookup for the whole value of that key. There are then two issues with your data definition:

1. The highest-priority of those values, which is the only one that matters in this case, does not provide the data that you are trying to retrieve via the lookup function.

2. As the diagnostic says, you have a recursive lookup: in order to load the value associated with key my, the lookup function within requires Hiera to first load the value of key my.

You could resolve (1) by specifying deep merging for my, but I do not expect that to resolve (2).

You need to restructure the data, bearing in mind Hiera's flat(-ish) data model. It's no particular problem for one of the items to be or contain a lookup table of IP addresses, but that can be referenced only externally or from the values of different items.

There's no need to create a new environment every time. You only do that once and then update the existing environment, i.e. use the following as step 5:

Trying to give an overview of how Linux, especially Linux on Z Systems and z/OS are different (or not). I'll need to simplify a lot to be able to keep it reasonably short.

Update 1: Changed some wording to be more clear, and corrected typos.

Linux is a UNIX-like operating systen that was first developed for Intel based systems (I think). Later, it became available for other hardware platforms, IBM Z Systems hardware being one of them. The Linux which runs on IBM mainframe hardware, or IBM Z Systems, is called Linux for System Z, or Linux on IBM Z; I'll call it zLinux hereafter for brevity.

Linux is Linux, no matter what platform it runs on. This is mostly true for: How you install it, how you configure it, how you run it, what API is provides, etc. Differences might exist when it comes to hardware configuration, or booting. This is especially true for zLinux.

Since the APIs are the same across, it offers source code portability, on an application level. And I consider the Java JVM an application in this context. Simplified this means, you take the source code, run it through the compiler that produces binaries for the target platform, and you're done.

What you optionally can do, is code optimization for the target platform, possibly to spead up things. In that sense the Java JVM for zLinux might work differently under the covers than the Java JVM for, say, an Intel PC platform (I actually don't know, if this is the case or not). But this would not matter to Java applications.

A program running on a UNIX system runs as process. Simplified, the term process includes control structures, and the virtual address space (memory, process image). To run another program, some program already running needs to fork(), then exec(). This will create a new process for that program.

The UNIX kernel does process management (programs runs as process), dispatching/undispatching onto/from a processor, memory management, file system management, priority management, user and group management using numeric uid, and numeric gid, etc., etc.

z/OS is one of IBM's mainframe operating systems, which run on IBM Z Systems hardware. Though running on Z Systems, like zLinux does, z/OS has not much in common with a Linux, or UNIX system. Installation, configuration, and running z/OS couldn't be more different.

MVS, born in 1964, is a component, or part, of any z/OS system. Its kind of like what the kernel is to a UNIX system. MVS provides the APIs that programs running on z/OS call. I call such a program an MVS program here. These APIs, again, are completely different to UNIX APIs. So, even though the hardware is the same, binaries are not exchangable. You cannot easily port a UNIX program into a z/OS MVS program; you have to rewrite from scratch.

MVS does task management (programs run as tasks), dispatching/undispatching onto/from a processor, memory management, data set management (MVS does not understand "UNIX file system"), priority management, user and group management using alphanumeric userid, and alphanumeric groupname, etc. etc.

In the early 1990s, IBM wanted to make it easier to port popular UNIX programs to z/OS, so the added UNIX APIs, and called this part (finally) z/OS UNIX System Services, short z/OS UNIX hereafter. This came out in 1994. z/OS UNIX is another component of z/OS (also called OMVS). It is not a full UNIX kernel, but only adds to MVS what is required by UNIX, what MVS does not aleady have, foremost, process management, numeric uid, and gid, and a UNIX-like file system.

IBM added everything required to become an xOpen and Posix compliant operating system. Now, you don't have to rewrite the UNIX program to run it on z/OS, you can more or less easily port it. There still are differences to cope with, foremost the dreadfull EBCDIC - ASCII difference. But API calls are 1:1, provided the program only uses compliant APIs.

There are three kinds of programs:

1. Programs that know nothing about UNIX, only use the MVS APIs, and deal with MVS data sets for I/O. Let's call them MVS programs.
2. Programs that were ported from UNIX, or written by someone who only knows UNIX, which know nothing about MVS, only use the UNIX APIs, and deal with UNIX directoies and files for I/O. Let's call them pure z/OS UNIX programs. (Well, this category does nor really exist, see *) below).
3. Programs that know both MVS, and z/OS UNIX, which call MVS, and z/OS UNIX APIs, and deal with MVS data sets, as well as with UNIX directories, and files. Let's call them mixed mode pograms.

*) Every program needs memory, and every program wants to become dispateched on the processor eventually. Memory management, and task management is provided by MVS, not the UNIX kernel, so unknowingly, the program calls MVS APIs under the covers. Conclusion: There is no such thing as a "pure z/OS UNIX program". That leaves us with categories 1 and 3, only.

All of those programs are stored as program objects, and reside either as member in a load library (data set), or as file in the UNIX file system. When run, the executable is loaded from either source in to an MVS address space, and is started as a task. All programs are managed as MVS tasks, have got all the MVS attributes, plus in case 3 above, also have UNIX attrributes (process id, uid, gid, etc).

A program of type 1, becomes type 3 at runtime as soon as it makes a call to a UNIX API. So, there is no such thing as a wall, or boundary, or subsystem. It's all MVS programs, that may also be UNIX programs at the same time.

The Java JVM that runs on z/OS is no exception. It has been ported to z/OS, and since this was easier, as z/OS UNIX program (well "mixed mode program", as you should know by now). It has been optimized for the hardware and the specifics of z/OS in many aspects. But to Java applications it is not different. Java applications are not binaries, so the same Java byte-code runs on any Java JVM (with exceptions).

I have similar issues on my local machine, what I do then is:

docker-compose down and docker-compose up if this does not help then I delete volume, be aware that volume will be named differently that in yaml file, it contains prefix ie:

You'll most likely want to use a Factory or Provider for your manager. The factory or provider can produce the correct Manager based on the action parameters. Then you may not need to continue passing the appId around, since each Manager is written for a particular app.

1. SDL.hpp contains two SDL_Renderer* members: renderer and gRenderer. Remove the former and update this line in SDL.cpp to use the latter:

I think manipulating standalone configuration files directly is not a good idea and is also error-prone.

There are some scripts to do this, delivered with jbpm:

Here is how to do it:

It is actually a known bug, fixed in Alfresco 6.2.2.2 :
https://alfresco.atlassian.net/browse/MNT-21758

Installing ACS 6.2.2.21 fixed the issue.

It is sad that this ticket (or the whole website ? ) is not indexed by search engines...