Hi Team,

We have developed a click to dial application using DMCC Java API and with the help of sample application provided in sdk. Its working fine when I tested with my extension(Avaya one-x agent(h.323)/Avaya workplace(sip)) but when we rolled out to few production users, it is failing intermittently with the error "ch.ecma.csta.errors.SubscribedResourceAvailabilityException".
We are assuming that this is because lack of licenses available, could be wrong, we think that way because when we restart the DMCC services on AES, the calls worked fine for some time and again seen same errors little later.

Is there any way to find out how many licenses being used by click to dial application/DMCC API?

In my code, I am acquiring one monitoring services(static variable) and using that for all agent extensions, I am doing that to improve the performance of application and avoid creating service provider and monitoring services for every agent extension and the phone call they make from that extension. With this code, once the agent extension used to place the phone number, that extension will be keep monitored infinitely, does this hold any license? I mean does it acquire the license for that extension and keep it until the extension completely unmonitored?


AES version: 7.1.3.2.0.2-0
CMAPI: cmapijava-sdk-7.1.1.0.0.51

Please find the code snippet:

private static Map<String, MyCallControlListener> callControlListenerMap = new LinkedHashMap<String, MyCallControlListener>();
private static ServiceProvider provider;
private static CallControlServices callControlSrvs;
private static ServiceProviderListener serviceProviderListener;
private static MonitoringServices monitoringSrvs;
private static MyShutdownThread shutdownThread;
private MyCallControlListener myCallControlListener;

private boolean useTelUri = false;
private String agentExtension;
private String cmLinkNameOnAes;

if (provider == null) {

provider = ServiceProvider.getServiceProvider(spProp);

Log4jLogger.debug(request, "Got the service provider instance");
serviceProviderListener = new MyServiceProviderListener();
provider.addServiceProviderListener(serviceProviderListener);

if (shutdownThread == null) {
shutdownThread = new MyShutdownThread();
// to handle system exits and application crashes
Runtime.getRuntime().addShutdownHook(shutdownThread);
}

try {
callControlSrvs = (CallControlServices) provider.getService(ch.ecma.csta.callcontrol.CallControlServices.class.getName());
} catch (Exception e) {
Log4jLogger.error(request, "Exception occurred while getting CallControlServices instance: " + e);
throwError = true;
throw e;
}

try {
monitoringSrvs = (MonitoringServices) provider.getService(ch.ecma.csta.monitor.MonitoringServices.class.getName());
} catch (Exception e) {
Log4jLogger.error(request, "Exception occurred while getting MonitoringServices instance: " + e);
throwError = true;
throw e;
}
} else {
Log4jLogger.debug(request, "ServiceProvider instance already exist");

}
if (callControlListenerMap != null && callControlListenerMap.get(agentExtension) == null) {
// this is to have 'one' call control listener per extension because calls made through that extension can be controlled with one listener
myCallControlListener = new MyCallControlListener();
try {
monitoringSrvs.addCallControlListener(getDeviceID(agentExtension), myCallControlListener);
callControlListenerMap.put(agentExtension, myCallControlListener);

} catch (Exception e) {
Log4jLogger.error(request, "Exception occurred while adding call control listener to monitoring services for the agent extension: " + agentExtension);
throwError = true;
throw e;
}
} else {
myCallControlListener = callControlListenerMap.get(agentExtension);
Log4jLogger.debug(request, "CallControlListener is already exist for agent extension: " + agentExtension);
}

try {
// dial the number
ucid = dialNumber(request, dialedNumber, callerId);
} catch (Exception e) {
// TODO: handle exception
}



Thanks,
Ram

When an application places a Call Control monitor on a station, it will (apart from some limited exceptions) consume one TSAPI Basic license. The license will be released after the monitor is stopped.

It is not possible to find out how many licenses are available/consumed via DMCC but it is possible to get useful information via SNMP.

The AES MIBs have some fields which should be useful for this:

avAesTsapiLicenseAcquired.1
avAesTsapiLicenseTotal.1
avAesDmccLicenseAcquired.1
avAesDmccLicenseTotal.1

You you can simulate near-real-time license values by polling these values periodically.

The Total values seem to show the total number of licenses in the license file (even if licenses have been allocated to secondary WebLMs or reserved by AESs).
The Acquired values show how many licenses are currently in use. Note that avAesTsapiLicenseAcquired does not seem to update immediately - it can take a few seconds to reflect a license being used/released. Also, avAesTsapiLicenseAcquired seems to include spare reserved licenses while avAesDmccLicenseAcquired shows the number actually in use.

There are some FAQs related to DMCC and license consumption. The following is not directly related to what you are doing but I think it is quite comprehensive.
https://www.devconnectprogram.com/site/global/products_resources/avaya_aura_application_enablement_services/support/faq/dmcc/index.gsp?tab=other&accordion=faq-630

There are also some TSAPI license FAQs which are relevant to you as DMCC Call Control uses TSAPI:
https://www.devconnectprogram.com/site/global/products_resources/avaya_aura_application_enablement_services/support/faq/tsapi/index.gsp?tab=private&accordion=faq-10

Martin

there are complexities in trying to access the information FROM an application as Martin points out. I think your desire is to simply find out how many are being consumed so you know what the problem you are facing is. If you login to the WebLM server that AES is using it will show licened entitlement, and currently consumed license counts. In the past it showed high watermarks for consumption as well. It has been a while since I looked but would hope both values are still shown. Normally you can access the WebLM UI from System Manager Web UI. Again they have re-arranged that UI enough times I am not certain where to find the link, but it is fairly obvious if you spend a few minutes looking for "License*" in the UI screens.

Thanks Martin and John,

Martin, I was looking around to see the values you mentioned in SM MIB and AES SNMP on web GUI, but not able to find those parameters. I could be missing something, just to be on same page, are they accessible through web GUI or I need to retrieve them programmatically using same DMCC API?

John, yeah, we are seeing 100% license utilization on webLM UI of system manager.

My next question is, if I change my code to monitor the extension before making call and release it after the I see the "EstablishedEvent" does it remove holding the licenses, I am assuming my current code hold the license for each and every extension since it will be monitored infinitely. But still thinking that even if I change the code to monitor just before the call and release after connected, its kind of returning the license to pool, but if there is a case all my extensions makes a call concurrently at one point of time, do I still need the number of licenses equal to the number of extensions?(The chances of having all extensions having concurrent calls are very less but there could be change of having concurrent calls of at least 30-50% of extensions)

I am still curious to know, does my application uses TSAPI licenses or DMCC licenses(basic or advanced)? since I am not doing any call recording in this application.

Thanks,
Ram

You will need an SNMP Agent to view the MIB. https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol for more information.

I am pretty sure the license will be held until at least the end of the call, even if you have stopped the monitor. It definitely will be held for the duration of the call if you used DMCC Call Control to make the call.

DMCC Call Control is just a wrapper for TSAPI. Hence the use of TSAPI licenses. There is some notes about TSAPI licenses in the DMCC programmers guide

Martin

From what you have said your application is just doing a Call Control Monitor - thus just consuming TSAPI Basic Licnese.
You would have to do a DMCC Device Registration before a DMCC License would be consumed and you have not mentioned that to date.

A TSAPI Basic License is held while the monitor is active, or if there is no monitor on the device during the processing of a request through the TSAPI Service (e.g. MakeCall(), ClearConnection(), Hold(), etc ). If the application uses Single Step Conference it is held for the duration that the added party remains in a call regardless of if the party that added them remains in the call or leaves it.

There are a set of TSAPI related license FAQs here: https://www.devconnectprogram.com/site/global/products_resources/avaya_aura_application_enablement_services/support/faq/tsapi/index.gsp

Since we do not understand your full requirements, nor the reason that you are putting a monitor on the station in the first place, we cannot advise on the suitability of removing the monitor once the call was placed.

Thanks Martin,

So, my DMCC API call control application requires only TSAPI licenses. I ordered DMCC licenses along with TSAPI what I have, I will ask to remove them, thanks!
And it is better to have the number of TSAPI licenses equal to number of extensions I monitor to make the calls, am I right? Just to avoid any failures in peak time where all extensions makes concurrent calls.

Thanks,
Ram

John, as far as I know, I am not doing any device registration(unless the DMCC API library does anything in the background of the code for call control) but get the Device Id of the agent extension and called phone number when making a call. I am using monitoring services to add the "addCallControlListener" such that I can listen the call control events(CallControlAdapter) ServiceInitiatedEvent, OriginatedEvent,DeliveredEvent,EstablishedEvent,ConferencedEvent,ConnectionClearedEvent,CallClearedEvent..etc.
But I am not doing anything on these events, for my current requirement I do not need to listen for these events, except interested to see the ConnectionClearedEvent to know which party released the call which is also not a mandatory at this time.
So, curious, if I do not to listen any of these events, and just make the call and forget, in that case, do I still need to have the basic TSAPI licenses? I assume, yes, because you mentioned makeCall also uses the license, just want to be double confirm.
And if I just to do the makeCall and forget in my application(also get the ucid as part of its response, which is very important), how long the license will be held? does it going to be hold until the call is released? or just at the point of time when making the call and release after the call initiated? this is to better plan for the number of licenses since we may not make calls from all extensions concurrently.

Thanks,
Ram

If you do not use RegisterTerimalRequest, you will not consume any DMCC licenses.

If you use MakeCall, you will consume a TSAPI Basic license (VALUE_AES_TSAPI_USERS) AKA "TSAPI Simultaneous Users" while the Calling party is in the call. Normally, this is the duration of the call but if, for example, the call becomes a conference and the original Calling party drops out, the license will be freed at that point.

Martin