What Changed

• Monthly CSPUs (targeted fixes)
• Quarterly CPUs (unchanged, cumulative)

Upcoming CSPU Schedule:

• May 28 – CSPU
• June 16 – CSPU
• July 21 – CPU
• August 18 – CSPU

What To Do

1. Add a monthly patch window
2. Review CSPUs immediately upon release (critical issues only)
3. Apply if relevant
4. Test fast: DV → PY → PD
5. Continue applying quarterly CPUs

Bottom Line

• CSPU = faster critical fixes
• CPU = full patch baseline

Adjust your patch cycle or you’ll lag on security.

How are you handling patches and on how many instances?

I’ve been working with JDE for 24+ years and I’ve never noticed that in the F986110, the JCPRTQ (Data Dictionary = Print Queue) column is used to store the port number of the JDE services running on the execution host. It has nothing to do with the Print Queue.

I’ve seen documentation that it’s been this way since at least 2002 (JDEList.com).

The F986110 has 20 columns. A brief description is below and the full table definition is on jde.erpref.com.

It looks to me like JDE didn’t have enough “Future Use” columns and had to use what was there because of their own limitations on creating tables/files.

Did you know this already?
Any idea what the story behind this might be?

https://linkedin.com/pulse/jde-cnc-developer-1-stewart-schatz-imwie

What is rsync?

rsync (remote sync) is a file-copying tool that uses a unique algorithm to minimize data transfer by copying only the differences between source and destination files. This makes it ideal for backups, mirroring directories, or syncing files over a network.

The basic syntax is straightforward:

rsync [options] source destination

Basic Local Sync Example

To sync a local directory, use the following command:

rsync -av /source/directory/ /destination/directory/

What’s Happening Here?

• -a (archive): Preserves symbolic links, permissions, timestamps, and more.
• -v (verbose): Outputs detailed information about what’s being synced.
• The trailing / ensures only the contents of the source directory are copied, not the directory itself.

Syncing to a Remote Server

To sync files or directories to a remote server, combine rsync with SSH:

rsync -av /local/directory/ user@remote_host:/remote/directory/

And to pull files from the server back to your local machine:

rsync -av user@remote_host:/remote/directory/ /local/directory/

By default, rsync uses SSH for secure transfers. If you need a different protocol, you can specify it with the -e flag.

Useful Options for rsync

rsync offers many options to customize its behavior. Here are some of the most commonly used ones:

• --delete: Removes files from the destination that no longer exist in the source. Be cautious with this option to avoid unintended data loss.

rsync -av --delete /source/directory/ /destination/directory/

• --exclude: Excludes specific files or directories.

rsync -av --exclude '*.log' /source/ /destination/

• --dry-run: Simulates the sync process without making any changes. This is especially useful for testing your command before running it.

rsync -av --dry-run /source/ /destination/

• -z: Compresses files during transfer to save bandwidth, particularly useful for remote syncing.
• --progress: Displays progress for each file during the sync.

Advanced Example: Backing Up a Website

Let’s say you want to back up a website hosted on a remote server to your local machine:

rsync -azv --delete user@remote_host:/var/www/html/ /local/backup/html/

In this command:

• -z: Compresses files during transfer.
• --delete: Deletes files in the local backup that no longer exist on the server.
• -v: Provides detailed output about what’s being synced.

Why Use rsync?

• Efficiency: Only changes are transferred, saving time and bandwidth.
• Flexibility: Works locally and remotely, with extensive options for customization.
• Reliability: Maintains file permissions, timestamps, and symbolic links, making it ideal for backups.

The rsync command is a must-have tool for anyone managing files on Linux. Whether you’re syncing directories locally, backing up to a remote server, or automating file transfers, rsync is fast, reliable, and highly configurable. Start with the basic options and experiment with advanced features like --exclude and --delete to optimize your workflow.

Do you have any tricks using rsync or other tools? Share them in the comments.

More info:

• https://en.wikipedia.org/wiki/Rsync
• https://linux.die.net/man/1/rsync
• https://ss64.com/bash/rsync.html

Viewing Stored Credentials

To see the credentials stored on your system, use:

cmdkey /list

This command displays a list of all stored credentials, including the targets they’re associated with, similar to the following:

Target: Domain:target=TERMSRV/127.0.0.1
Type: Domain Password
User: user@domain.local
Local machine persistence

Target: LegacyGeneric:target=git:https://gitlab.com
Type: Generic
User: username
Local machine persistence

Adding New Credentials

You can create a new stored credential using the /add option. For example, the command below can be used to store credentials for a network share. Those credentials will be securely stored and automatically used when accessing the target.

cmdkey /add:SERVER /user:username /pass:password

Deleting Stored Credentials

To delete a specific stored credential, use the /delete option:

cmdkey /delete:SERVER

Why Use Stored Credentials?

One of the most valuable uses of the cmdkey command is to avoid storing usernames and passwords as plain text in scripts when automating repetitive tasks. For instance, you can add credentials for a remote server before configuring and running a scheduled task that uses those credentials. That way, you don’t have to store the credentials in plain text within your script.

The cmdkey command is a valuable utility for managing stored credentials, especially when working with network resources. By using options like /add, /list, and /delete, you can securely store and manage authentication details for remote systems. Integrate it into your workflow to streamline tasks that require credentials, but always prioritize security.

The xcopy command is a versatile tool in Windows for copying files and directories. Unlike the basic copy command, xcopy allows for more complex copying tasks, making it particularly useful when dealing with large, deep directory structures. In this post, we’ll cover essential xcopy functions and options to help you streamline your file management tasks.

Basic XCOPY Usage

To use xcopy, open Command Prompt and type:

xcopy [source] [destination] [options]

Example: The following command copies all files from C:\Source to D:\Backup:

xcopy C:\Source D:\Backup /s /e

Key XCOPY Options and Their Use

xcopy comes with multiple options to customize the copy process. Here’s a rundown of the most commonly used ones:

• /s: Copies directories and subdirectories, excluding empty ones.
• /e: Copies all subdirectories, including empty ones.
• /h: Includes hidden and system files.
• /d: Copies only files that have changed since the last copy.
• /y: Suppresses prompts to confirm overwriting existing files.

Copying Entire Directory Structures

To copy a folder and all its contents, including empty folders, use both /s and /e:

xcopy C:\Projects D:\Archive /s /e

Updating Changed Files Only

If you want to save time by copying only files that have been modified, add the /d option. For example:

xcopy C:\Projects D:\Archive /d

Copying Hidden and System Files

By default, xcopy skips hidden and system files. To include these, use the /h option:

xcopy C:\Projects D:\Backup /h

Avoiding Overwrite Prompts

To run the command silently without prompting you to overwrite existing files, add the /y flag:

xcopy C:\Projects D:\Backup /s /e /y

That command is ideal for scheduled or automated tasks where you need minimal interaction.

Limitations and Alternatives

While xcopy is effective for many tasks, it does not support advanced permissions copying. If you need this feature, consider robocopy, which offers more granular control over permissions.

Conclusion

The xcopy command provides a straightforward way to copy files and directories in bulk, with options that allow you to manage large and complex file structures. With options like /s, /e, and /d, you can create efficient copy routines suited to your specific needs. Whether you’re backing up files or managing large projects, xcopy is a valuable tool in your command-line toolkit.

Finding and Removing Empty Directories

The find command is a powerful tool for searching files and directories based on various criteria. To clean up empty directories, you can use the following command:

$ find . -type d -empty -exec rmdir -v {} +

Here’s a breakdown of how this command works:

• .: The dot represents the current directory. You can replace it with any directory path where you want to start the search.
• -type d: This option tells find to search only for directories.
• -empty: This flag filters the search results to include only empty directories.
• -exec rmdir -v {} +: This part of the command executes the rmdir command on each empty directory found. The {} is a placeholder for each directory name, and the + at the end allows find to pass multiple directories to rmdir in a single command, which is more efficient. The -v option makes rmdir output a message for each directory it removes, giving you feedback on the process.

This command is safe and efficient because the rmdir command only removes directories if they are empty, ensuring no unintended deletions.

An Alternative Approach

If you prefer a more straightforward method, you can use the -delete option in the find command:

In this command:

$ find . -type d -empty -delete

• -delete: This option tells find to directly delete any empty directory it finds. It’s a more concise command, but it doesn’t provide the same level of feedback as the -exec rmdir -v approach.

Choosing the Right Command

Both methods are effective, but they offer slightly different benefits:

• Use -exec rmdir -v if you want to see which directories are being deleted, as it provides real-time feedback.
• Use -delete if you prefer a simpler command and don’t need output for each deletion.

Conclusion

Cleaning up empty directories can help maintain an organized and clutter-free file system. By using the find command with either the -exec rmdir or -delete options, you can automate this task and save time. Whether you prefer detailed feedback or a quick, silent operation, these commands provide the flexibility to match your needs.

PowerShell Script to Print Directory Structure

To print and save the directory structure of a folder, use the following PowerShell script:

Tree "C:\Root" /f /a | Select-Object -Skip 5 | Set-Content C:\Root\dir.txt

Explanation of the Script Components

• Tree “C:\Root” /f /a: This command generates a directory tree.
  • /f: Displays the names of the files in each directory.
  • /a: Uses text characters instead of graphic characters to show the lines that link subdirectories.
• Select-Object -Skip 5: Skips the first 5 lines of the output, which usually contains header information.
• Set-Content C:\Root\dir.txt: Saves the output to a file named dir.txt in the C:\Root directory.

Sample Output

The script will produce a text file (dir.txt) with the following structure:

+---Test1
|   |   File1.txt
|   |   File2.txt
|   |   File3.txt
|   |   
|   +---Test1.1
|   |       File1.txt
|   |       File2.txt
|   |       
|   \---Test1.2
|           File1.txt
|           
+---Test2
|       File1.txt
|       File2.txt
|       File3.txt
|       
+---Test3
|   \---Test3.1
|           File1.txt
|           File2.txt
|           
\---Test4
        File1.txt

Why Use This Script?

This PowerShell script is especially useful for:

• Documenting directory structures for project documentation.
• Explaining directory layouts to both technical and non-technical colleagues.
• Auditing file and folder structures for organization and management.

Conclusion

By using this PowerShell script, you can easily create a visual representation of any directory structure and its contents. This method is efficient and can be a valuable tool for various administrative and documentation tasks.

I hope this guide helps you manage and present your directory structures more effectively!

More posts on PowerShell and other scripts.

NtCreateFile (\Device\VBoxDrvStub) failed: 0xc0000034
STATUS_OBJECT_NAME_NOT_FOUND (0 retries) (rc=-101)

Make sure the kernel module has been loaded successfully.

where: supR3HardenedWinReSpawn what: 3 VERR_OPEN_FAILED (-101) – File/Device open failed. Driver is probably stuck stopping/starting. Try ‘sc.exe query vboxsup’ to get more information about its state. Rebooting may actually help.

To resolve this issue:

1. Locate the VBoxSup.inf file. Usually found here: C:\Program Files\Oracle\VirtualBox\drivers\vboxsup
2. Right-Click the VBoxSup.inf file and select [Install]
   
3. Open a command prompt as Administrator and run the following command:
   sc start vboxsup
4. Start your VM

Hopefully, this helps. If you have another way of resolving the issue, let me know.

The solution is to:

1. Delete the current Node Manager Windows Service
   C:\sc delete "NODE_MANAGER_WINDOWS_SERVICE_NAME"
2. modify the installNodeMgrSvc.cmd and add the highlighted portion:
   set JAVA_OPTIONS=%JAVA_OPTIONS% -Dweblogic.RootDirectory=%DOMAIN_HOME% -Djava.library.path=%WL_HOME%\server\native\win\x64
3. Run the installNodeMgrSvc.cmd as Administrator

I hope this helps you when having issues trying to get the Oracle WebLogic Node Manager to start as a Windows Service.

Weblogic.nodemanager.common.ConfigException: Native Version is Enabled but Nodemanager Native Library Could not be Loaded (Doc ID 1301911.1)

NodeManager does not Start. Log Shows Error: weblogic.nodemanager.common.ConfigException “Native version is enabled but NodeManager native library could not be loaded” (Doc ID 2875144.1)

Start NodeManager Fails with Error “no nodemanager in java.library.path” (Doc ID 2907887.1)