Why Does LinkModelToNode Return Bad Not Implemented?

Child-object method calls complete after the child node is linked to its runtime model and the parent object's generated method-dispatcher setup runs during object creation. Bad Not Implemented means the server can expose the Method node but has no callable implementation registered for that runtime instance.

Common fixes that miss the dispatch layer

The number that matters is the number of completed runtime bindings, not the depth of the object hierarchy. A visible Tracking object and Method node prove that the address-space model loaded; they do not prove that a dispatcher can route the call to application logic.

Changing input values or retrying the call also leaves the missing binding unchanged. The failure occurs before application logic processes the inputs.

Runtime dispatch path

A method call crosses several layers: the client identifies an Object and its Method, the server resolves those nodes, the runtime model supplies the corresponding object instance, and a dispatcher invokes the implementation. The generated address-space description covers node identity and relationships. Executable behavior requires the separate runtime association.

For Transport Info, the child Tracking node must be associated with the model that owns its method implementation. The parent object's dispatcher initialization must then register method handling across that created object structure. If either step is absent, the Method remains browsable while a call returns Bad Not Implemented. This is dispatch state, not object nesting.

A successful browse followed by an immediate call failure therefore narrows the fault. Node creation has progressed far enough to expose the model, but method registration has not produced a callable target for that instance.

Binding prerequisites and limits

There is no useful retry count for an unregistered method: zero completed dispatcher registrations means every call to that instance follows the same failure path. Likewise, no timing delay repairs a creation sequence that never invokes the setup routine.

Parent-and-child binding procedure

1. Locate the code path that creates the runtime instance of Transport Info. Use the path executed for the actual instance visible to the client, not an unused generated template or type definition.
2. Confirm that creation also instantiates or resolves the nested Tracking node. Record the node identity shown by the server browser so later breakpoints can be correlated with the same instance.
3. Follow the generated LinkModelToNode path and verify that the model association includes the child node that owns the Method. Linking only the parent is insufficient when the child requires its own model association.
4. Invoke the generated setmethoddispatchers routine as part of parent-object creation, after the object hierarchy and model links required by that routine exist. Call it once for each newly created runtime parent instance that needs callable child methods.
5. Keep custom method logic in the generated extension point intended for application code. If UaModeller output is regenerated, compare the integration boundary so dispatcher initialization remains in the active creation path.
6. Restart or recreate the runtime objects so existing instances are rebuilt with the new association and dispatcher state. Editing initialization code does not retroactively bind an instance that has already been created.

The exact placement depends on the generated lifecycle, but the ordering test is fixed: the relevant nodes must exist, their models must be associated, and dispatcher setup must execute before the client call.

Call-path verification

1. Browse Transport Info, then Tracking, and confirm the expected Method is attached to that child instance.
2. Trace parent creation and verify that setmethoddispatchers executes for the same runtime instance. A breakpoint hit during startup is useful only when its object identity matches the browsed node.
3. Trace the child model association through LinkModelToNode. Confirm that the linked model is the object containing the implementation, rather than a parent-only or unrelated instance.
4. Place a breakpoint at the first line of the method implementation and issue one client call. The breakpoint must be reached before judging input handling or output behavior.
5. Confirm that the result no longer reports Bad Not Implemented, then validate the method's outputs and side effects separately. Dispatcher success proves routing; it does not prove that the application algorithm is correct.

If setup executes but the implementation breakpoint remains untouched, inspect which node and model instance were passed into the linking and registration paths. Duplicate address-space instances can make the correct routine run against the wrong object.

Recurring lifecycle pitfalls

Initialization order is the dominant trap. Calling dispatcher setup before the child node exists can leave nothing to register, while linking a model after dispatcher setup can leave the registration associated with incomplete runtime state. Put traces around node creation, model linking, and dispatcher setup to establish the actual order.

Regenerated code is another boundary to watch. Generated files may be replaced, while application-owned initialization remains. Keep the call that activates generated dispatchers in the supported integration area and verify it after regeneration rather than editing generated output repeatedly.

Type nodes and instance nodes also serve different purposes. A Method described on a model or type can appear correct while a created instance lacks its runtime implementation. Diagnose the exact instance called by the client and repeat the binding procedure for every dynamically created parent object.

FAQ