Runtime Messages

Other Runtime Questions

Answers in this category:

Answers in this category:
Message; "op_prt_buf, print new page fa".
Message; “free_pool() - attempting to free unallocated memory ()”
Message; “Internal Error has Occurred, Proceed with Caution”
Message; "Cannot write any more qdaemon"
Message "memcpy - trash the heap"
Message; "unknown AppxIO status"
Message; "Can't connect to host"
Message; “PDF_begin_page: Function must not be called in ‘page’ scope”
Message; “Connection Refused by Host”
Message; “Application Lock verification failed. Access Denied”.
Message; “can't write cwdgt - Error - Already on File”
Message; “Cannot read cfi_rec”
Message: “mm_free() 'freeing watched address' or 'attempting to free freed memory'"
Message; "pl rloc - too few cchld records(1)"
Message; “ID not defined as valid Login”
Message; “File Organization Specification Mismatch”
Message; “License Server not Detected”
Message; "file does not exist"
Message; "Can't connect to Host" or "Connection refused by host" (Troubleshooting WinAppxD)
Message; "Allocation of TOKEN_USER failed"
Message; "LookupAccountSid() failed"
Message; "can't open stream socket"
Message; "can't bind local address"
Message; "op_prt_buf, print new page failed"
Message; “There was an error opening this document. No such file or directory”
NET_LOG 'error's 122 & 10054
PDF Output: "Windows cannot find $display"
Message: "required data was not placed into memory because of an I/O error"
Message – “Error - Invalid Request Using Main ARB”
Message "Found active record on freelist"
Message. "ERROR - CANNOT ACCESS REQUIRED FILE"
What does error "Can't read LFN File - Error - Already on File" mean?
Message, "can't empty sarb list"
Message, "bad reg no."
Message "An unexpected error occurred, please enable logging and retry"
Message "Cannot write to Cache - Invalid Prototype Record Length"
Message; "No Record Currently Held"
Message, Error - Request Not Allowed
Message, "BI.C - APPX Startup Failure: Unable to Initialize Window Manager"
Message: "key field conversion failure - Error - Invalid Logical Value"
Message; "too much data"
Message, "Network IO Error"
Message, "ORA-01000: maximum open cursors exceeded"

If you can reproduce the error, we'd love to get a copy of the replication, so we can fix it. Frequently the error is not easily reproducible, so any scenario we can get that reproduces it would be helpful.

       "Enq: (FATAL ERROR): 0781-024 Cannot write anymore to
       /var/spool/qdaemon/to4mZM"

The /var file system is full. Delete some unneeded files out of the file system.

This error occurs when a page break triggers another page break. For example, setting "new page before" on a page heading frame. Refer to bugtracker bug #517 and #617

1. winappxd/appxdsvc (listener) is not running on the server (host)
2. the port you entered is not valid for the listener(s) you have running
3. the workstation is not connected to the server where the listener is running

Referring to item 3 above. If you are entering a server name and you are sure the listener is running and the port is correct, try entering the ip address of the server instead. If you connect, most likely your DNS name is not mapped to the right ip address. You will have to resolve your DNS server mapping to eliminate this error.

This error occurs when Appx takes the snapshot (after you've had a chance to change the widgets with ILF code).

The primary key to the internal widget file is position row+position col. There's an alternate unique key that on name + appearance number. Check for duplicate name+appearance number.

PL.C.2842 - "Cannot read cfi rec - Error - Record Not in File",

followed by "Internal Error Has Been Detected, proceed with caution!".

To diagnose these, set the two environment variables:

        APPX_TRAILER_COUNT=40

        APPX_LABEL_MEMORY=1

When then running into the above error messages, send a copy of the error message itself (a screen snapshot if possible) to Appx technical support.

On Windows platforms, also send a copy of the 'appx.stk' file found in the same directory as the Appx engine. (It may then be safely deleted.)

Consider also performing the cleanup steps described in: http://www.appx.com/assets/asp/dynamic_generator.asp?pageid=584

It did let him enter an OS login of "RND/abc". But when he then logged into his OS as RND/abc, then into Appx, it told him - "Bad User Id - The User Id you are currently using was not found in the APPX user file."

VAR deleted .\data\0SA\Data\USER.* in order to be able to enter Appx. In Security > Users he tried entering "abc", but it gave him the "not currently defined" message. It did let him enter an OS Login ID of "RND/abc", but again wouldn't let "abc" log in.

VAR didn't notice that there was the word "Warning" in front of the first message. Because of confusion of local IDs and domain ID, Appx validates against the domain id, but allows entry of only the user portion of the Domain/User ID.

I.E., "abc" works for logging in, but generates a Warning during OS Login ID Entry. "RND/abc" doesn't work for logging in, but generates no warning during OS Login ID entry.

If you're in a Domain environment, enter only the user part of the user's OS Login ID. Also, ignore the "Warning - This ID is not currently defined..." message.

Note, this message was changed from 'Error' to 'Warning' in 4.1.8. If your Appx version is prior to 4.1.8, it's probably necessary to upgrade to 4.1.8 or higher in order to be able to enter OS Login ID’s.

You can also get this error if a file is damaged. If a {file}.dat is damaged and you rebuild the {file}.key from it, you may or may not get an error message indicating that there's a problem in the .dat. If you get no message, you could be left with the impression that your .dat/.key pair are good. Running verify may or may not tell you if there's a problem. (This is a low probability, but possible scenario.)

Your safest course of action is to run through the "What to do with a file That Fails Verification" procedure in

http://www.appx.com/assets/asp/dynamic_generator.asp?pageid=624

You can do a bit more investigation using the techniques in "Verifying and Analyzing a File" on that webpage. Using the utility program Recover.exe is the recommended course of action. Exporting and re-importing the file will work however may result in more lost data. The Export program will only read to the "bad spot" on the file and stop whereas Recover.exe will continue to the end of file reading and writing records beyond the error. Information on this utility can be found at the above address.

 appx -l=logfile

Consider deleting the data\0SA\Data\USAGE.*, .\REGISTER.dat, and .\LOCK.* files, then re-import the registration.

For an NT based Presentation Server (WinAppxD), see the FAQ “Service is not running” for debugging approaches. Also for NT Presentation Server:

1) Bring up the Task Manager and look for a WinAppxD process, which should tell us whether WinAppxD is running.

2) Running "netstat -a" and looking for "*.8060" (for example) in the "Local Address" list will tell you if anything is listening on the port. For example:

C:\WINDOWS> netstat -a Active Connections Proto Local Address Foreign Address State TCP oz:1079 P66:0 LISTENING TCP oz:1650 P66:0 LISTENING TCP oz:1656 P66:0 LISTENING TCP oz:1533 P66:0 LISTENING Services for WinAppxD has a radio button giving alternatives for 'System' or 'This Account:'. The latter should be on, with UserID equal to the APPX user set up for this Presentation Server. Try reentering the password for this User Account. Then Re-IPL.

For a Unix based Presentation Server:

To see what Presentation Servers are running, execute: ps -ef | grep appxd To see what ports (prefixed with '806') are being listened to: netstat -a | grep 806 Proto Recv-Q Send-Q Local Address Foreign Address (state) tcp 0 0 *.8064 *.* LISTEN tcp 0 0 *.8068 *.* LISTEN tcp 0 0 *.8067 *.* LISTEN.

Reboot and try again. If it still fails, call APPX Software Technical Support.

Resolution: Reboot and try again. If it still fails, call APPX Software Technical Support.

1. A lingering copy of WinAppxD. Check to make sure no copies of WinAppxD are listed in Task Manager. This may occur if you Start and Stop the WinAppxD service using Control Panel, or if you run WinAppxD from the command line during troubleshooting. If you see any rogue WinAppxD's, kill them and try again.

2. Some other (non-APPX) application wants to use the port you specified in the "-s=" argument for WinAppxD during installation. There is no completely reliable way to detect this. If you are getting the "can't bind" error and are sure it's not due to an extra WinAppxD process running, this is probably what has happened. Since WinAppxD can't use a port claimed by another application, go back and edit the registry, choosing a different port number for the WinAppxD service. For example, try 8061 instead of 8060. Reboot, and try again.

In the course of Appx/Clients attaching to a WinAppxD Appx/Server, with 
APPX NET_LOG enabled, the following NET LOG entries can come up.  Here are 
explanations:

        SetProcessWindowStation() returned 1, (err=122)
        CreateDesktop() returned 168 (err=122)

 These aren't errors.  They would be errors if they had returned 0.

        recv() failed, exiting, errno = 10054

 "An existing connection was forcibly closed by the remote host."
                                        (From the MS Win32 API Error Codes)

This can be caused by something in the network (aka an 'assassin') sending a 
RESET packet.  This kills WinAppxD, and therefore all links between 
Appx/Clients and the Appx/Server.  The Appx/Server may or may not be able to 
manually restart, depending on whether something in the network is holding the 
old port open or not.  If the port is being held open, the Appx/Server can't 
grab it again.

That "something in the network" could be routers, modems, or other equipment 
in the network.

                 $display:         (can look like "Sdisplay")

 Windows cannot find '$display:'. Make sure you typed the
 name correctly, and then try again. To search for a file,
 click the Start button, and then click Search.

                    OK

     Appx - 41440:  appx.exe - application error

  The instruction at 0x004992b0 referenced memory at 0x004992b0.   
  The required data was not placed into memory because of an 
  I/O error status of 0xc000020c.

There were most likely occasional, brief network problems when trying to load a block of appx.exe executable into his client PC. This can happen after initial appx.exe -c program loading, because the OS grabs 2k blocks of the disk form of the executable, as needed. (The problem can also be a disk fark, or a controller error.)

The solution is to bring the appx.exe previously stored on the network server down to the local PC hard drive, to eliminate this potential network problem.

This error can also happen when a temporary file is created in a process and that temporary file is not deleted completely. Under normal conditions, APPX will delete temporary files (Disk Related for example), when the process ends. Look for the presents a .key components without a corresponding .dat for the file in your database directory for the offending application. Delete the .key file manually if necessary.

'sarb' is an abbreviation for 'slave arb'. A sarb is a slave to a 'marb' (a master arb). An 'arb' is an access request block - it's the internal representation of a file stream. When you OPEN a file, you get a new arb. Appx creates arbs for you when you BEG/END READ, or when you invoke a new process.

Recommended course of action, determine what process was running then look at the file(s) that were open. Check the number of alternate keys. Appx allows for 1 primary and 15 alternate keys. If you exceed this you could get this error. You should also delete the em(s) and run the process again.

You may see this message from Subroutine CSE. CSE is the Call Statement Editor.

* It tries in 4 different places to open the USAGE file and if it fails it sets this flag.
* Tries to lock some kind of sentinal record, a failure sets this flag.
* If it fails to read a USAGE record in 2 cases it sets this flag.
* If it fails to writed to the USAGE file it sets this flag.

The basic problem might be a corrupt USAGE file.
That message means exactly what it says - enable logging and retry (then, of course, check the log).
The license server always produces a minimal log file (the file name displays when the license server starts or you can appx -l=filename). To turn up the logging level, set APPX_LS_DBG=0xFFFFFFFF
The easiest fix would be to delete the USAGE file. If that doesn't work, we need the log.

APPX can maintain three threads to the same file; one for the PCF, one for READ/READNEXT and one for BEG READ/END READ loops. When you READ the PCF in ILF (sub-process level), it resets the hold pointer depending on the READ specifications. That’s why the STORE, READ with hold, and RESTORE in Pre-PCF Update works. It re-established the hold on the record APPX automatically read from the PCF. Of course the interactive phase is import too. Appx won’t hold the record in Inquire mode for example. Also keep in mind that the data record is also stored in the common area and subsequent READ statements may replace the record read (and perhaps displayed) from the PCF. It can be a slippery-slop when you start messing around with the PCF in your application. There are certainly situations where it’s necessary but it could be done accidentally as well.

A record will be released by the REWRITE, DELETE, or CLOSE statements. Why, Appx assumes when you execute any of these commands you are done with the record.

As mentioned above, a READ or READNEXT creates a second thread into the file but uses the same common area as the parent. So if you access the PCF in ILF with hold, the hold pointer and record buffer are changed in the common area. When you return to your input screen after the events points, or sub-process child have executed APPX expects the PCF record to be held (in change mode). Since you re-established the hold in ILF, the hold at the PCF level has been lost. This might be what is happening in your case. That’s what the message is in the status line (in red) is telling you. If you tried to REWRITE or DELETE a record in ILF and didn’t have the hold, Appx would display the ILF code that was causing the problem.

You can also release the hold by invoking a sub-process child that uses the same PCF as the parent. Sub-process children share the common area with the parent. Basically the same thing happens as a READ, but APPX has read the file and may have reset the hold. This would happen on an input process invoked as a sub-process that has the same PCF as the parent.

You should analyze your system to determine where the hold is being released. We can’t tell you specifically where to look because, as described above, the hold can be release in any number of ways depending how your system is coded. If this just started happening, I would find out what has recently changed and investigate what the programmer may have done that resulted in this situation.

Perhaps something is being changed in the data dictionary that alters the length of the current buffer and Appx maybe has a copy of the data stuck is a save buffer that it is trying to restore.

Most of the time this error is the result of lack of permissions on the Appx directory. Appx users must have full control within the Appx directory and all sub-folders within it. They also need to be able to run the Appx executable on the server with logon local rights.

We have seen this error caused by a spam filter. If any new spam/virus filters been added to your server in the past few months, could you turn them off briefly to test connectivity?

You might get this error if you're running a newer version of the client than the engine. Example, running Appx 4.2.a with the 5.0.1 client.

It has been found that exiting a BEG READ/END READ loop that is accessing an Oracle table will not close cursors properly. In this case you should write your Appx ILF process to always execute the END READ statement for each READ.

Tuning OPEN_CURSORS

The best advice for tuning OPEN_CURSORS is not to tune it. Set it high enough that you won't have to worry about it. If your sessions are running close to the limit you've set for OPEN_CURSORS, raise it. Your goal in tuning this parameter is to set it high enough that you never get an error during normal operations.

If you set OPEN_CURSORS to a high value, this doesn't mean that every session will have that number of cursors open. Cursors are opened on an as-needed basis. And if one of your applications has a cursor leak, it will eventually show up even with OPEN_CURSORS set high. Your DBA should be able to monitor the number of open cursors.

After you've increased the value of OPEN_CURSORS, continue monitoring to see if opened cursors keeps increasing for any of your sessions. If you have an application session whose opened cursors always increases, then you've likely got a cursor leak in your application code: your application is opening cursors and not closing them when it's done.

There is nothing you (DBA), can do to fix a cursor leak. The application developers need to go through the code, find the cursors that are being left open, and close them. As a stopgap, the most you can do is raise OPEN_CURSORS very high and schedule times when all the application sessions will be closed and reopened.

How not to tell if you're closing all your cursors

Frustratingly for developers, the session statistic 'currently open cursors' can include some cursors that the application has closed. When application code calls for a cursor to be closed, Oracle actually marks the cursor as "closeable". The cursor may not actually be closed until Oracle needs the space for another cursor.

So it's not possible to test to see if a complex application is closing all its cursors by starting a session, running a test, and then checking to see if currently open cursors has gone down to 1. Even if the application is closing all its cursors properly, currently open cursors may report that some "closeable" cursors are still open.

One way for application developers to tell if an application is closing all its cursors is to do a single test run, on a dedicated development box, while monitoring opened cursors for the session that's running the test. Then set OPEN_CURSORS to a value a little bit higher than the peak cursors open during your test run, start a new session, and run through multiple iterations of the same test run. If your application still has a cursor leak, you will see the value of OPEN_CURSORS going up, and you may hit an ORA-1000 after a reasonable number of iterations. (Don't set OPEN_CURSORS too low or it may be used up by recursive SQL; if your single test run opens very few cursors, consider making your test run longer rather than setting OPEN_CURSORS unreasonably low.)

Answers in this category:
What is the difference between END and CANCEL?
Is there a way to pass login nformation to APPX?
Is there anyway to force the appx client to open in a specific size window?
Graphic resource(s) not being displays (red X)?
What does the check mark on the Java client do?
Checking the APPX registration number.
Is the date/time a user signs in and out of APPX kept?
Pasting data into a text field in APPX.
How do you set up keystroke playback (keyboard scripting)?
How do you turn off dynamic indexing in APPX?
What is dynamic indexing?
What are the maximum file size(s) in APPX?
How to determining who has a file open (Unix OS).
No Beep on Errors and Warnings
What are the command line options?
Diagnose SUBR --- SEND FILE TO CLIENT problems
More information about why the --- SEND FILE TO CLIENT subroutine failed?
Scan hangs!
Am I running Java Client?
What's "appx.exe -f=" mean?
How to recover from record "locked".
How to determine what are my environment variable are?
APPX/Client startup problems
Slow APPX Login Time
Auto-update Java Client version
How are usage locks allocated?
Appx/Client timeout duration
Action Logs don't generate
General AppxODBC recovery
Appx-Client scrambled display on Startup Login
How to turn off full selection (highlighted) of text fields in change mode.
What kind of code does APPX generate?
Is there any "standard" screen size as it relates to the GUI interface?
Is there any way to increase the screen response time using the APPX client.
Several commands which I can RUN successfully on our HP-UX 11.0 system, do not work when invoked on a Redhat Linux 9 system.
Diagnosing Appx/Client problems
home
Performance Issues
Memory corruption after calling an external subroutine.
How do we use the routine --- READ FROM CLIENT CLIPBOARD?
Asql Errors
Would adding "-session" to a command line cause APPX to respond to any input screens with an END?
What does error "Appx startup failed because of the following startup error: 34" mean?
How can i tell from the ILF code what screen size user has?
I can get the PID number from the usage file, but where can I get the port number?
What does -session flag do when added to a command line?
Previous Activity key
Does APPX run on Mac OS X Server?
Performance issues when using a RDBMS
Appx and new Daylight Savings time
What does "Corrupt lfb list" C-Assert mean?
How to uninstall AppxODBC.

END returns to the previous RELATED process level and continues operation. CANCEL returns to the DETACHED process level and continues operation. This may sound very similar but are actually quite different. A simplified answer is that END terminates the current process and goes back one level, while CANCEL terminates the current process and may go back more than one level.

For example, when a report is selected from a menu it may start a job that has several steps. It may contain an input that asks for a date range, a query that will select and sort records based on that date range, a disposition to direct the report to the desired device, and an output that actually creates the report. In this case the menu is the parent of the job, which is considered DETACHED since creating the report is not dependent on any information received from the menu. The input, query, disposition, and output steps of the job are RELATED, since the task depends on successful completion of each step.

If you are on the disposition screen and you decide that you want to terminate the report you must decide whether to press END or CANCEL. If END is pressed, then the disposition is terminated and control is returned to the RELATED level, or the job, and processing continues. In this case the output would then run, creating the report that you thought you were exiting. On the other hand, if CANCEL is selected the disposition is terminated and control is returned to the DETACHED level, or the menu. This skips any remaining RELATED steps of the job, giving the desired results.

A) If you want to run with more Appx screen rows and columns, start the client with the following options:

AppxDesktopClient -rows=28 -cols=110

This will launch the client that has been sized to allow this number of application Rows and Columns. Similar to running a non-24x80 xterm window and running Appx.

B) If you want to launch the client with a different screen font size, that controls the overall size and magnification of the Appx Client screen. You can do that with a different startup option:

AppxDesktopClient -initialFontSize=14 &

This will launch the client using that base font size instead of the default it is currently using. The base font size is used by the client to set the overall Appx client window size and also how to scale all the screens it presents. The screens will be 'zoomed' to fill the Appx screen. Similar to starting to client today and dragging out the border to a different size.

 
                 APPX_DISABLE_DYNAKEYS=1

Bruce Johnston 15, '04:
You can also create a dynamic index via ILF (at least from 4.1 through 4.2.2).
Given two fields, DGA FDRFEPR FED WASTE PRE and DGA FDRFEPR FED WASTE SUF, if I want to sort by the PRE and then by the SUF, both in ascending order, I use the following...
      PASS     DGA FDRFEPR FED WASTE PRE      FIELD            SHARE? N         
      PASS     DGA FDRFEPR FED WASTE SUF      FIELD            SHARE? N         
      CALL         ,PI_DYNA_BLD               RESIDENT? N  END? N  FAIL 0       
If I wanted to change the default order of any to reverse it I'd simply double up its PASS command as in...
      PASS     DGA FDRFEPR FED WASTE PRE      FIELD            SHARE? N         
      PASS     DGA FDRFEPR FED WASTE SUF      FIELD            SHARE? N         
      PASS     DGA FDRFEPR FED WASTE SUF      FIELD            SHARE? N         
      CALL         ,PI_DYNA_BLD               RESIDENT? N  END? N  FAIL 0       
which gives the records sorted by the PRE in ascending order followed by the SUF
in descending order.

I believe that it was Korry who first told me this.

The maximum file size is dependent on the release of APPX and the operating
system.  The following chart shows the maximum file sizes allowed for each
operating system based on the release level of APPX.

              Maximum file sizes by release

Release   Windows    AIX       Solaris   HP/UX     Linux
=======   ========   =======   =======   =======   =======  
4.2       2 GB       4 GB      4 GB      4 GB      4 GB
4.1.a     2 GB       4 GB      4 GB      4 GB      2 GB
4.1       2 GB       4 GB      4 GB      2 GB      2 GB
prior     1 GB       2 GB      2 GB      2 GB      2 GB

==> The problem was that the AIX operating system wouldn't allow files larger than 1 gig to be written to the file system. An OS parameter needed to be changed: the /etc/security/limits file, fsize parameter was set at 2097151. They changed it to -1 and the problem went away.

Prior to this change, executing the 'ulimit -a' command returned:

 time(seconds) unlimited file(blocks) 2097151 data(kbytes) 131072 stack(kbytes) 32768 memory(kbytes)32768 coredump(blocks) 2048 nofiles(descriptors) unlimited

 time(seconds) unlimited file(blocks) unlimited data(kbytes) 131072 stack(kbytes) 32768 memory(kbytes) 32768 coredump(blocks) 2048 nofiles(descriptors) unlimited

The value for file(blocks) is the limit on the file size in 512k blocks that can be written. After the change the value is unlimited and the size of file that can be written is limited only by the available disk space.

                  Fuser –u /user/appx/data/VV/AAA/Data/Bugvar.dat

                  /user/appx/Data/VV/AAA/Bugvar.dat: 15846(tom)    18211(appx)

1) Check that the Windows Sound Control's "Mute" isn't on, and that mixer volumes (Wave, Synth, Line, CD, etc.) are all set on high.

2) Try deleting Appx/Client cache files (Win2k: C:\Documents and Settings\{yourWindowsID}\.appx\cache\).

3) The "Toolkit.getDefaultToolkit().beep()"code may or may not be what your desktop expects as the default beep. It may be associated with another control. Go to Control Panel > Sounds and Multimedia > Sound Events. Is there a Sound Event named "Default Beep"?

If not, go to Microsoft Knowledge Base Article 300406 http://support.microsoft.com/default.aspx?scid=kb;en-us;300406 titled: "Default Sound Is Unavailable in the Sounds Tool in Control Panel", and follow its instructions.

If there is a "Default Beep" Sound Event, check to see if it has a .wav file associated with it and that the .wav file really exists. If there is not a .wav there, set one and see if that works. If one does exist, try setting a .wav association with the Windows program events that do not have a sound attached until you find the one that works.

4) Try re-installing the Appx/Client.
.

              Toolkit.getDefaultToolkit().beep()

... to the Java VM (rather than fire off a .wav file). The Java VM forwards that request on via the Windows OS to the external speaker, but it's possible it's going thru the Client PC's BIOS => internal speaker to produce a beep. (We can't really tell, as this is internal to the Java VM.)

It's possible something you installed or uninstalled may have changed the sound associated with the event the Toolkit.getDefaultToolkit().beep() is sending.

Command Line Options

-application=(APPX server Application ID) Instructs the server to startup in a particular application ID. (not implemented)

-bg=(color) Background color (See -fg for color list).

-bmode=(tile|expand) default=tile Defaults how background tiles are painted in the Java window. The “tile” setting uses the tile image over and over again to fill the window. The “expand” setting resizes the image to just fill the space inside the window. Used with the –splash= setting.

-boldFg=(color) Set the default text foreground text color for bold text (See –fg for color list).

-cols=(window size in columns) default=80 Defaults the initial screen size in columns.

-database=(APPX server Database ID) Instructs the server to start in a particular database. (not implemented)

-editBg=(color) Set the default text foreground text color for edit fields (See –fg for color list).

-fg=(color) Valid colors are black, blue, cyan, darkGray, gray, green, lightGray, magenta, orange, pink, red, white, yellow, or any valid #rrggbb number. Set the default text foreground color. Defaults to black.

-font=fixed Turns off the proportional font normally used by the Java client. If you are having problems with the text on your application screens not lining up the way you want, try this setting.

-hideMenu (not implemented)

-hideToolbar (not implemented)

-host=(server hostname) Defaults the remote host field on the remote login pane of the login dialog box. It is also used when the login dialog box is skipped.

-look=(java|windows|motif) default=windows Defaults the look and feel setting on the “options” pane of the login dialog box. It is also used when skipping the login box.

-mode=(local|remote|both) default=both Controls which login panels are shown and also determines which type of login to do if the login in dialog box is skipped.

-optkey=(character) Resets the key used as the option key. The default is the single back quote character (`, left of the 1 on the QWERTY keyboard. To set the option key to the ~ character, use –optkey=~

-password="(server OS password)" Defaults the password on the remote login pane of the dialog box. It is also used when skipping the login box.

-pathname=(path & filename of the local appx.exe file) Defaults the location and name of the APPX server when running APPX locally. This is also used when skipping the login dialog box and the –mode=local is set.

-port=(server port number) default=8060 Defaults the remote server port number on the login dialog and also used when doing a remote login with the login dialog box skipped.

-process=(APPX server process name) Set startup process name.

-ptype=(menu|job|input|output|...etc...) Sets the startup process type.

-rows=(window size in rows) default=21 Defaults the initial screen size in rows.

-shell=(command line to start a document) Overrides the default command line used to ‘start’ a document. Starting a document is telling Windows to open a document and having Windows use the association for that document type to decide which program to use. This defaults to start (document), which might not work on NT. NT may require this to be set to start the command shell like “cmd.exe /c start”.

-smode=(tile|expand) default=expand Defines how the splash image is painted on the Java window. The “tile” setting uses the tile image over and over again to fill the window. The “expand” setting resizes the image to just fill the space inside the window. Used with the –splash= setting.

-splash=(url to an image) Used as a background image in the main client window during the login process. How it is painted is determined by the –bmode= setting.

-tile#=(url to an image) Defines an array of images that the client will use to fill window backgrounds. –tile1= defines the base wallpaper image. –tile2= defines the wallpaper for all one up from the base window. –tile3= sets the pattern for all windows two up from the base window, etc. You can define as many or as few as you like. The client will cycle back to the first image if you have more windows layered on the screen for which it has tile images. Used with the –bmode= setting.

-title="(text/information to display)" Replaces the default text in the title bar of the client with the text and optional data specified in this parameter. Supports the following options; $(host) displays the host id, either name or IP as entered in login $(user) displays the user login id $(pathname) displays the engine path $(pid) displays the server task id $(port) displays the port the connection is attached through Example: -title=”Host is $(host), PID is $(pid), on server port $(port)”

-user=(server OS userID) Defaults the userid on the remote login pane of the dialog box. It is also used when skipping the login box.

home

This should also provide useful information if you're having problems with:

        SUBR --- LOAD URL ON CLIENT.

See also: How do I send a file to a client PC and open the file with a client side App? (i.e. Excel)
_

In APPX 4.1 and higher, you can use the following code:

        SUBR --- CHECK GUI CLIENT     SUBPROCESS  END? N
        IF   --- RETURN CODE             EQ    1
  T     it's the java client
  F     it's not

When the server is spawned, it inherits a bunch of file descriptors from winappxd. One of these file descriptors is the TCP/IP connection from the client. The "-f=" flag tells the server which file descriptor is connected to the client.

After completing the spawn, winappxd closes it's copy of the client file descriptor and the server starts talking to the client on the indicated descriptor.

The APPX session is probably still running on the server, and that's what's holding the record.

You need to do one of the following:

- Have a look at the registration usage to see if there is an orphaned session for that user. If you can find it, KILL it from the console.

- Use NTHandle on the server and find the PID that has the file. Then kill it. At the heart of it, NTHandle digs out the PIDs and the open files. You still have to parse through NTHandle, once you have it from www.sysinternals.com

- Ask everyone to log off, stop the WinAppxD and License servers, and kill any remaining APPX sessions on the server. If there are background jobs running, it might be tricky to identify the background jobs from the ghost task.

- Identify the process id's of all currently connected clients (look in the title bar if P/M client, or under the 'About' menu if Java) and kill everything but those. Again, watch out for background jobs, if you use them at your site. Also, you might want to stop the WinAppxD service while you do this to prevent new users from logging on while you try to find the ghost process.

- Download and install the BJutils package. This is Bruce Johnston's APPX utility package, and one of the utilities allows you to see who has what files open and also allows you to kill APPX sessions. This would help you identify which APPX session is holding the record. You can get this from www.cansyswest.com, under Free Stuff. You also need the NT Resource Kit to make these work.

- Reboot the server (simple, but drastic)

In addition, key file corruption can cause locking problems. It is not unlikely that externally killing an APPX process may cause key file corruption.

So you should run a 13)Verify 1)Integrity on any files that may be open when you have a record locking problem, for which you end up either killing processes, or re-IPL'ing with APPX processes still running.

If you're having record locking problems, it might also be prudent to run 13)Verify 1)Integrity on a regular schedule, perhaps monthly.

To determine your environment variables under Unix, perform:

       RUN          set > /tmp/env.txt

To determine your environment variables under APPX for Windows:

       RUN          cmd /c set >C:\tmp.txt
       RUN          wordpad.exe C:\tmp.txt

 (Under Windows 9x, use command.com rather than cmd.exe.)

If you're running APPX/Client, have the first RUN redirect standard out to a  
file in a client-accessible directory, then run an editor on that file.

To get the environment variable using ILF, try;

      SET      --- TEMP 80          =      cd /tmp;
      APPEND   --- TEMP 80          1      set > env.tmp;
      APPEND   --- TEMP 80          1      grep APPX env.tmp >
      APPEND   --- TEMP 80          1                env.txt   ;
      APPEND   --- TEMP 80          1      rm env.tmp
      RUN      --- TEMP 80

Set the environment variables APPX_NET_LOG and APPX_NET_MASK to have APPX create a log file of why the client is not being started.

If that doesn't work, perform:

   1) Download a fresh copy of the APPX Java Client ('javacli.exe').

   2) Create a new directory (renaming or deleting the old one if necessary).
      Run this 'javacli.exe', installing it into this new directory.

   3) Reboot the client PC.

   4) Try to run 'appxjava.exe' from the new directory.

   5) If it fails, from a DOS window, do a "set" command.  Email the value
      of IBMHPJ_OPTS to us at techsupp@appx.com, along with the location of the
      directory into which you installed the Client.

Over the past 6 months, our APPX login times have steadily lengthened. 


Normally this symptom is due to a growing USAGE file.  Other likely events;


- network traffic in general has increased on your network

- more users in APPX

- more PC’s on your network

- do you have the APPX client stored on a local disk on each client PC, or
  are  you retrieving it from the network any time someone logs in?  (See the
  WinAppxD FAQ, ftp.appx.com/pub/documents/winappxd-faq.txt, section 2.12: 
              "Automatically update Presentation Client".)

- It's also possible that you have a DNS or WINS issue 

Example of a batch file that can start APPX and automatically update the 
APPX/Client to the most recent version prior to logon:

rem  AppxJAVA.bat
rem  Batch file to launch Appx Java Client and keep it updated.
xcopy x:\Appx\StartUp\Images\splash.jpg c:\"Program Files"\AppxClient\
                        themes\default\ /d
xcopy x:\Appx\StartUp\login.ini c:\"Program Files"\AppxClient\ /d
xcopy x:\Appx\StartUp\JavaClientUpdate\AppxClient.exe c:\"Program Files"\
                        AppxClient\ /d
xcopy x:\Appx\StartUp\JavaClientUpdate\Appx.jar c:\"Program Files"\
                        AppxClient\ /d

"C:\Program Files\AppxClient\AppxClient.exe" -cols=80 -rows=25
                 -title="Appx -$(user) on $(host):$(port), PID $(pid)
exit

The following batch file does the same for the Appx Windows Client.

rem AppxWin3.bat
rem 09/03/99 PAK
rem
rem Batch file ran on each client at startup of Appx
rem i.e., the Appx Desktop shortcut should point to this file
rem
rem XCOPY switches:
rem /d - Copies only those files whose source time is newer than
rem      the destination file.
rem /i - If destination does not exist and copying more than one file,
rem      assumes that the destination must be a directory.
rem /u - Copies only files that already exist in destination
rem
rem Copies the Latest Version of Appx to your computer!
rem
xcopy x:\appx\appx.exe c:\Appx\Win32\ /d

md c:\Appx\Win32\data
xcopy x:\appx\startup\winprint.exe c:\Appx\Win32\data\ /d

rem for WinNT, HOSTS file is in: Winnt\system32\drivers\etc\
xcopy x:\Appx\Startup\Hosts.* c:\Winnt\system32\drivers\etc\ /d /i
xcopy x:\Appx\Startup\Hosts   c:\Winnt\system32\drivers\etc\ /d
start c:\Appx\Win32\Appx.exe -c

When you run the first process in a locked application, Appx acquires a USAGE (this means that you are using 1 user right from that product registration). When you run the second, third, fourth, etc. processes in that application, you don't count as 2, 3, 4, etc. users - just a single user.

When you end ALL processes in the locked application, it decrements the usage count for the appropriate lock. If the usage count for a lock goes to zero, the lock is forfeited, and therefore the overall user count for that lock is decremented. (You are no longer counting against the user rights for that product registration)

If the user gives us a host name (as opposed to a numeric IP address), we have to convert that to an IP address, using the TCP/IP stack on the client machine. If the server's name is in the hosts file (/etc/hosts or %WINDIR%\System32\drivers\etc\hosts), the conversion should be nearly instantaneous.

If the server's name is not in the hosts file (or if file-based lookup Has been disabled), the conversion requires a network conversation with a DNS name server - that can take quite a while.

If the name cannot be resolved, you'll get an "Invalid Host Name" error after a while.

If the host is not reachable, the IP protocol specifies some number of retries (and some waiting period in between retries) before the TCP/IP stack gives up and tells Appx that the host is unreachable.

We run a job for a post and the action log normally behaves correctly, 
but on occasion no log is produced.  But in a subsequent job for 
another group, the action log contains items (usually Warnings) for 
this post, as well Warnings from the first post.

You'll have more control over the format of your Logfile, and you can use DISPOSITION functions to direct them. You could also use ILF to update an ancillary error tracking file, if you want a more permanent record of errors encountered, by whom, and when.

 1) In Control Panel > Administrative Tools > Data Sources(ODBC) > 
          System DSN tab => Remove the AppxODBC record. 1) Uninstall AppxODBC.
 2) If 'C:\appx.env' exists, delete or rename it.
 3) Delete appxodbc directory tree (which contains the 'appx.dbs' tree).
 4) Search for and delete appxodbc.dll and appxsetp.dll.
 5) Reboot.
 6) Reinstall AppxODBC from a downloaded AppxODBC installation package.

         http://board.appx.com/faq/cache/232.html 

Right Click on your Windows Client Desktop > Properties > Settings Tab > Advanced... > Troubleshooting Tab > Hardware Acceleration slider. Click it to the left, perhaps all the way to "None". That should straighten out the display. If it doesn't, call Appx Support.

So we don't really generate code in the way that some tools do. We don't generate C code that then gets compiled into a program. Appx is a compiler, interpreter, and VM all rolled into a single package.

I use 28x100 because it creates a nice sized and readable screen on a 17” monitor when using a resolution of 1024x768. It fills the screen nicely, but has a font that is large enough to easily read.

My personal preference is 28x110. This size fits nicely on 17" monitors with a resolution of 1024x768.

We chose to set the standard at 21 X 97. This will fill a screen when the resolution is set at 800 X 600. It gives us some extra screen real estate, particularly in the width where its most useful, but doesn't strain the eyes of our older employees.

0 = Paint every screen 1 = Skip some intermediate screen repaints 2 = Skip all intermediate screen repaints

Screen painting is the most intensive thing the client can do.

--- TEMP 132 is loaded with:

ln -s -f /ft/mv90/test.PRN/home/appx/data/TST/UBS/Data/MV9IRPRN.dat

RUN --- TEMP 132

You can rule out the first problem by including the complete path to the /bin/ln program.

To check on the second problem. RUN the command "id > /tmp/myid", then look at /tmp/myid. You'll probably see that you are running as user appx rather than yourself s you might expect.

Make sure that the destination directory is modifiable by $(cat /tmp/myid)

home

Note: appxlog.txt is initialized when a user starts a new session, so you must capture it before the user starts a new session.

See also Diagnose SUBR --- SEND FILE TO CLIENT problems and Where is Java/Client cache?.
`

Unix & Linux:

   $HOME/.appx/

   C:\Documents and Settings\{yourWindowsID}\.appx\

   C:\WINNT\.appx\

Files are created in Tmpdata for large sorts and for temporary disk files created by application(s). Under ideal circumstances, APPX removes all temporary files at the end of the job that created them. However, if a job is interrupted, the temporary files are not automatically removed and, over time, they can accumulate. So, the system administrator should routinely remove them when performing system maintenance to keep them from accumulating.

APPX has to choose a unique file name when creating a temporary file. Determining a unique file name can take some time if there are a lot of files in the Tmpdata directory.

If users are actively in Appx, you should not blindly remove the contents of the tempdata directory. But if all users are out, then it is perfectly fine to remove the contents.

-Reorganize active files

"Active" data files should periodically be "reorganized" whether or not they are APPXIO, C-ISAM, Oracle, or whatever.

Files and disk drives should be defragmented periodically.

-Orphan APPX sessions

Check for "orphaned" APPX sessions on the server that might be consuming system resources.

-Network errors

Check for "high" error counts on your network that might be causing slow response or "orphaned" APPX sessions on the server.

-Logging

Check your enviromental variables to see if you are creating any dianostic log files that are not needed.

      PASS     Rq: Buffer                     FIELD            SHARE? Y

      PASS     Op: Total Chars in Clipbrd     FIELD            SHARE? Y

      PASS     Op: Max Num Chars to Read      FIELD            SHARE? N

      GOSUB    --- READ FROM CLIENT CLIPBOARD                           

The first field is a field to receive the clipboard data.
The second field will be filled in by the routine telling you how many bytes were in the clipboard.
The third field is optional and if used you set it to the max number of bytes you want to read. It will default to 32767 if not set.

It depends on the platform. If you're running a Linux or Unix server, the operating system, background jobs will pretend like the user pressed the END key whenever a process gets to a point where it would normally wait for user input.

On Windows servers, the OS doesn't really provide anything that differentiates between a foreground and background process - there isn't a notion of a "background process" on Windows (except for a Windows service, which is something else entirely). Instead, when you spawn an Appx background job on a Windows server, we just start another copy of Appx (minimized). Try running Appx on a Windows server without running in client/server mode - run a background job that needs to wait for user input. When you spawn the job, you should see another copy of Appx show up in your task bar. Open that window and you'll see the background job running. You can interact with it using the keyboard and mouse. It's just a second Appx session that starts in the right place, has a copy of all of the parent session's important data, and starts minimized. Just like the specification says: separate task allowed? Very handy for debugging background jobs.

However, that's an old feature that was written before we had a client/server configuration. If you connect to appxdsvc or winappxd, the broker creates an invisible desktop for the engine sessions - that means that you can't get to any background sessions. We should probably modify the Windows engine so that it notices that you're running in client/server mode and behaves more like Unix/Linux of you are.

      PASS     --- RI                         FIELD            SHARE? Y
      PASS     --- CI                         FIELD            SHARE? Y
      GOSUB    --- GET SCREEN SIZE 

QUERY <some query name> JOB DISPOSITION - consists of one INPUT process OUTPUT <some output name>

When the user is at the INPUT process of the nested job, and they press F4 to go back, it continues to the OUTPUT. Why does it do this? Can I get it to return to the previous job step?

Yes, you can get it to return to the previous job step. Make sure that your JOB DISPOSITION step is invoked as a Subprocess, not as "related", and make sure that "Separate task" box is not checked. That should do the trick.

There are 3 things that controls if you can or can not return to the previous activity:
1. NEXT CHILD ID - it controls job steps and is shared at the subprocess level. Normally it's set to "+", which means "move forward"
2. Separate task set to "Y"
3. There is a hidden filed on a CHILD file called "Prev Img Ok" - not 100% sure what exactly sets in ON or OFF, but i think it's ON by default now.

1) commit frequency
2) Length of data read/written
3) Read with hold
4) # of database I/O's
5) communication protocol and settings

I'll briefly discuss each.

1) commit frequency (Commit Mode, Process Additional Attributes).

We have determined that a commit is very "expensive" in terms of performance. If you can reduce the number of commits, then performance will almost always increase, sometimes significantly. Deferring commits to the End of Process probably maximizes performance for this factor but may increase the size of the rollback logs and will certainly increase the number of rows in the database which are "locked" to other users while updates are pending.

2) Length of data read/written

This may be the most significant factor which impacts performance. As the length of the data being read or written increases, the run time increases, sometimes dramatically. This is why we added the Partial Record I/O feature. If possible, you should avoid reading the entire record if the record is large. How large? I seem to remember that each increment of about 800 bytes caused a significant incremental loss of performance. Even if you must read the entire record, then try to avoid a rewrite of the entire record. If you are only updating a single field, then do a rewrite of just that field. If you are rewriting several fields, wrap them in a group and rewrite the group. If necessary, you can add a "group" of synonyms to the end of the record to accomplish this.

3) Read with hold

Don't read with hold unless you need to. If you are only going to actually update a small percentage of the records read, read each record first without a hold and then, after you determine that an update is needed, read it with hold. A read with hold is very "expense" in terms of performance. Keep in mind that an output or update process will automatically read the PCF with hold if a REWRITE or DELETE statement is detected. If only a small percentage of records will actually be updated, it might be much more efficient to write a Subroutine process as an alternative to an update process.

4) # of database I/O's

Use the new file cache capability to load read-only "code" files into memory where they can be very efficiently read. Accessing of code files in a database is much slower than accessing the same code files from memory.

5) communication protocol and settings

If possible, install the Oracle database and APPX on the same machine so that you can avoid database I/O across a network. If they are both on the same machine, configure Oracle to use "pipes" for communication instead of TCP/IP. Define the ORACLE_SID environment variable instead of specifying the database name in the FMS group. APPX will then use the local communications protocol which will probably be pipes. Pipes are much more efficient than TCP/IP.

If you are using TCP/IP make sure that the packet size is large. I'm not sure how large you can define the packet size to be, but 10K or more might be desirable if you are reading/writing large rows.

Is Appx going to be affected by the new Daylight Savings Time?

APPX does not keep time – it simply reads what the operating system provides. 
As long as you have patched your OS properly, there will be no issues as far as 
APPX is concerned.

It means that Appx found an unexpected entry in a "scope list".  
When you open a file, Appx creates a "logical file block" (LFB) to keep track
of that file.  Every file is opened at some particular scope - when that scope
ends, the file is closed and the LFB is discarded (a scope is something like
"the most recently invoked related process", "the current event point", or
something like that).  The LFB is linked into a list of all LFB's belong to a
given scope.  This message means that Appx was processing a scope list and
found an LFB that should have been linked into a different list (because it
has the wrong scope).

It could be related to FLEP bug.