Installing Weblogic Portal 10.3.6 on MacOS

There’s a number of things that go wrong when attempting to install Weblogic Portal 10.3.6 on MacOS that I’ve covered a few years ago in posts here and here.

To get round these issues, when installing with the generic installer you’ll need to pass these options:

java -d64 -Dspace.detection=false -Xms1024m -Xmx1024m -jar portal103_generic.jar

Last time I needed to do this these options worked for me, although recently when I needed to do a new install I ran into this Fatal Error:

It seems the generic installer will only succeed on most recent versions of MacOS if you install with Java 6. You can chose a Java 7 install to run Weblogic with as part of the install steps.

This post describes installing with Java 6 (and this one describes the same error). I didn’t need to fake out the additional paths/libs with symlinks etc that this post does, I just needed to set Java 6 to JAVA_HOME, and then it ran through to completion ok.

The Legacy Java 6 installer for MacOS can be downloaded from here:

Building a React frontend for my AWS Lambda Sudoku solver

Over the past few months I built an implementation of Donald Knuth’s Algorithm X using Dancing Links in Java to solve Sudoku puzzles.

This was a fascinating exercise in itself (you can read more my experience here), but the next logical step would be to package it up in a way to share it online.

Since I’m pursuing my AWS certifications right now, one interesting and low cost approach to host the the Solver implementation is to package it as an AWS Lambda. Sudoku Solver as a Service? Done. I exposed it through AWS API Gateway. It accepts an request payload that looks like this:


and returns a response with a solution to the submitted puzzle request like this:


The request and response payloads are an array of Strings, where each item represents a String of values concatenated together for one row in the grid, with ‘.’s for unknowns.

I’m still learning React as I go, and while building this front end for my Lambda Sudoku Solver I learnt some interesting things about React and Javascript. The source for the app is shared here.

I used Flux to structure the app, so there main parts of the app are:

  • a main, highlevel Container component,
  • a CellComponent that renders each cell in the Sudoku grid,
  • an Action that handles the interaction with the AWS Lambda
  • a Store that holds the results from calling the Lambda

I don’t want to focus on the pros and cons of using React or Flux (and this is not intended to be a how-to on building an app using React) as there were some other specific issues I ran into that were interesting learning opportunities. A couple of these I already captured in separate posts, so I’ll include these links below.

Iteration 1: onChange handler per row

My first approach to maintaining the state for the display of the grid and the handler for changes to each cell was to keep it simple and have a seperate array of values per row, and a separate onChange handler for each row. This is not a particularly effective way to structure this as there’s duplication in each of the 9 handlers.

The State looked like this:

this.state =
row1 : [],
row2 : [],
row3 : [],
row4 : [],
row5 : [],
row6 : [],
row7 : [],
row8 : [],
row9 : []

And each of the handlers looked like this, one handler per row, so handleChangeRow1() through handleChangeRow9():

handleChangeRow1(index, event){
console.log("row 1 update: " +;
var updatedRow = [...this.state.row1];
updatedRow[index] =
this.setState( { row1 : updatedRow } );

This approach needed 9 versions of the function above, each one specifically handling updates to the state for a single row. We’ll come back to improving this later.

The interesting thing to notice at this point that to update an array in React state, you need to clone a copy of the array, and then update the copy. I used the spread operator ‘…’ to clone the array.

Each row in the grid I rendered separately like this (so this approach needed 9 of these blocks):

{ (cell, index) => (
<CellComponent key={index} value={this.state.row1[index]}
onChange={this.handleChangeRow1.bind(this, index)}/>

This was my first working version of the app, at least at the point where I could track the State of the grid as a user entered or changed values in the 9×9 grid. Next steps was to improve the approach.

Iteration 2: Using an array of arrays for the State

The first improvement was to improve the State arrays, moving to an array of arrays. This is easily setup like this:

this.state =
grid: []

for (var row = 0; row < 9; row++) {
this.state.grid[row] = [];

Iteration 3: One onChange handler for all rows

Instead of a handler per row, I parameterized the onChange handler to reused for all rows. This is what I ended up with:

handleGridChange(row, colIndex, event) {
console.log("row [" + row + "] col [" + colIndex + "] : " +;
var updatedGrid = [...this.state.grid];
updatedGrid[row][colIndex] =;

//call Action to send updated data to Store

Using .map() on each of the rows in State, I then rendered each row of the grid like this, passing the current row index and column index as params into handleGridChange():

this.state.grid[0].map((cell, colIndex) => (
<td key={"row0" + colIndex}>
<CellComponent value={this.state.grid[0][colIndex]}
onChange={this.handleGridChange.bind(this, 0, colIndex)}/>

I’m sure there’s a way to use a nested .map() of the results of a .map() or some other clever approach to render the whole grid in a single go, but rendering each of rows individual is an ok approach with me since there’s only 9 rows. If the number of rows were much more than 9 then I’d spend some time working on a better approach, but I’m ok with this for now.

Flux Action and Store

The Action to call the Lambda, and maintaining the state of the responses in the Store was pretty simple. You can check out the source here if you’re interested.

CSS styling for the grid

One last thing to do was to style the grid so it looks like a usual Sudoku grid, with vertical and horizontal lines at 3 and 6, to divide the grid in 3×3 of the 3×3 squares. This took some reading to find out how to easily do this, but turns out CSS nth-child() psuedoclass handles this perfectly. I covered this in this post here.

Take a look at the app

I might move this to a more permanent home later, but if you want to check out the app, you can take a look here.

Adding a New Storage Datastore to ESXI 6.5 (on an HP DL380 G7), and fixing the “Failed to create VMFS datastore – Cannot change the host configuration” error

This is part 3 of 3 in a series on adding new drives and storage to my HP DL380 G7 server and ESXi. The previous 2 parts are here, part 1 – adding new drives, and part 2 – configuring a new RAID array.

After the previous two steps were complete, the new disks are in, the new RAID array configured, the next step is to add the storage in ESXi to be available to new VMs. Here’s my starting point, almost out of space:

Right now I have 1 Datastore configured in ESXi:

To add a new Datastore in ESXi:

At this point I ran into the error ‘Failed to create VMFS datastore’:

This post with steps to fix the partition table on the newly added drives. First step was to enable the sshd service to ssh into the server:

First, use this command to find the disk id of the newly added disk. Here I can see my new disk array as it’s the one closest to 1TB, the size of the new disks:

ls -lha /vmfs/devices/disks/

This command shows the issue with the partition table on the new disk array:

 partedUtil getptbl /vmfs/devices/disks/(disk ID)

Next, use this command to reset the partition table to msdos type for the new disk array:

partedUtil setptbl /vmfs/devices/disks/(disk ID) msdos

Repeating the previous steps to add the new datastore now works, new store added:

New storage space now looks good!

Checking in iLO on the newly added disks, looks good:

Also, taking a look at fan speeds after 30mins or so, fan speeds all look good!


Samsung S8 updated to Android Pie – where’s my Always on Display gone?

After a T-Mobile update to Android Pie, my Always on Display was no longer displaying. It seems like in Pie it initially defaults to only displaying with a touch to the screen. To change this, go to Settings, Lock Screen -> Always on Display – some of these setting screens have additional options if you scroll down. For example, the AoD settings page initially looks like this:

… but if you scroll down you’ll see additional options, including ‘Display Mode’:

Press Display Mode and change from ‘Tap to Show’ to ‘Show Always’ :