You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3216 lines
112 KiB
3216 lines
112 KiB
(function() |
|
{ |
|
var root = typeof(window) !== "undefined" ? window : typeof(global) !== "undefined" ? global : typeof(self) !== "undefined" ? self : {}; |
|
var ice = root.ice || {}; |
|
root.IceGrid = root.IceGrid || {}; |
|
ice.IceGrid = root.IceGrid; |
|
var Slice = Ice.Slice; |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
// |
|
// Ice version 3.7.3 |
|
// |
|
// <auto-generated> |
|
// |
|
// Generated from file `Descriptor.ice' |
|
// |
|
// Warning: do not edit this file. |
|
// |
|
// </auto-generated> |
|
// |
|
|
|
/* eslint-disable */ |
|
/* jshint ignore: start */ |
|
|
|
|
|
Slice.defineDictionary(IceGrid, "StringStringDict", "StringStringDictHelper", "Ice.StringHelper", "Ice.StringHelper", false, undefined, undefined); |
|
|
|
/** |
|
* Property descriptor. |
|
* |
|
**/ |
|
IceGrid.PropertyDescriptor = class |
|
{ |
|
constructor(name = "", value = "") |
|
{ |
|
this.name = name; |
|
this.value = value; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.value); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.value = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 2; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.PropertyDescriptor, true, true); |
|
|
|
Slice.defineSequence(IceGrid, "PropertyDescriptorSeqHelper", "IceGrid.PropertyDescriptor", false); |
|
|
|
/** |
|
* A property set descriptor. |
|
* |
|
**/ |
|
IceGrid.PropertySetDescriptor = class |
|
{ |
|
constructor(references = null, properties = null) |
|
{ |
|
this.references = references; |
|
this.properties = properties; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
Ice.StringSeqHelper.write(ostr, this.references); |
|
IceGrid.PropertyDescriptorSeqHelper.write(ostr, this.properties); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.references = Ice.StringSeqHelper.read(istr); |
|
this.properties = IceGrid.PropertyDescriptorSeqHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 2; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.PropertySetDescriptor, true, true); |
|
|
|
Slice.defineDictionary(IceGrid, "PropertySetDescriptorDict", "PropertySetDescriptorDictHelper", "Ice.StringHelper", "IceGrid.PropertySetDescriptor", false, undefined, undefined); |
|
|
|
/** |
|
* An Ice object descriptor. |
|
* |
|
**/ |
|
IceGrid.ObjectDescriptor = class |
|
{ |
|
constructor(id = new Ice.Identity(), type = "", proxyOptions = "") |
|
{ |
|
this.id = id; |
|
this.type = type; |
|
this.proxyOptions = proxyOptions; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
Ice.Identity.write(ostr, this.id); |
|
ostr.writeString(this.type); |
|
ostr.writeString(this.proxyOptions); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.id = Ice.Identity.read(istr, this.id); |
|
this.type = istr.readString(); |
|
this.proxyOptions = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 4; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ObjectDescriptor, true, true); |
|
|
|
Slice.defineSequence(IceGrid, "ObjectDescriptorSeqHelper", "IceGrid.ObjectDescriptor", false); |
|
|
|
/** |
|
* An Ice object adapter descriptor. |
|
* |
|
**/ |
|
IceGrid.AdapterDescriptor = class |
|
{ |
|
constructor(name = "", description = "", id = "", replicaGroupId = "", priority = "", registerProcess = false, serverLifetime = false, objects = null, allocatables = null) |
|
{ |
|
this.name = name; |
|
this.description = description; |
|
this.id = id; |
|
this.replicaGroupId = replicaGroupId; |
|
this.priority = priority; |
|
this.registerProcess = registerProcess; |
|
this.serverLifetime = serverLifetime; |
|
this.objects = objects; |
|
this.allocatables = allocatables; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.description); |
|
ostr.writeString(this.id); |
|
ostr.writeString(this.replicaGroupId); |
|
ostr.writeString(this.priority); |
|
ostr.writeBool(this.registerProcess); |
|
ostr.writeBool(this.serverLifetime); |
|
IceGrid.ObjectDescriptorSeqHelper.write(ostr, this.objects); |
|
IceGrid.ObjectDescriptorSeqHelper.write(ostr, this.allocatables); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.description = istr.readString(); |
|
this.id = istr.readString(); |
|
this.replicaGroupId = istr.readString(); |
|
this.priority = istr.readString(); |
|
this.registerProcess = istr.readBool(); |
|
this.serverLifetime = istr.readBool(); |
|
this.objects = IceGrid.ObjectDescriptorSeqHelper.read(istr); |
|
this.allocatables = IceGrid.ObjectDescriptorSeqHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 9; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.AdapterDescriptor, true, true); |
|
|
|
Slice.defineSequence(IceGrid, "AdapterDescriptorSeqHelper", "IceGrid.AdapterDescriptor", false); |
|
|
|
/** |
|
* A Freeze database environment descriptor. |
|
* |
|
**/ |
|
IceGrid.DbEnvDescriptor = class |
|
{ |
|
constructor(name = "", description = "", dbHome = "", properties = null) |
|
{ |
|
this.name = name; |
|
this.description = description; |
|
this.dbHome = dbHome; |
|
this.properties = properties; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.description); |
|
ostr.writeString(this.dbHome); |
|
IceGrid.PropertyDescriptorSeqHelper.write(ostr, this.properties); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.description = istr.readString(); |
|
this.dbHome = istr.readString(); |
|
this.properties = IceGrid.PropertyDescriptorSeqHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 4; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.DbEnvDescriptor, true, true); |
|
|
|
Slice.defineSequence(IceGrid, "DbEnvDescriptorSeqHelper", "IceGrid.DbEnvDescriptor", false); |
|
|
|
const iceC_IceGrid_CommunicatorDescriptor_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::CommunicatorDescriptor" |
|
]; |
|
|
|
/** |
|
* A communicator descriptor. |
|
* |
|
**/ |
|
IceGrid.CommunicatorDescriptor = class extends Ice.Value |
|
{ |
|
constructor(adapters = null, propertySet = new IceGrid.PropertySetDescriptor(), dbEnvs = null, logs = null, description = "") |
|
{ |
|
super(); |
|
this.adapters = adapters; |
|
this.propertySet = propertySet; |
|
this.dbEnvs = dbEnvs; |
|
this.logs = logs; |
|
this.description = description; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
IceGrid.AdapterDescriptorSeqHelper.write(ostr, this.adapters); |
|
IceGrid.PropertySetDescriptor.write(ostr, this.propertySet); |
|
IceGrid.DbEnvDescriptorSeqHelper.write(ostr, this.dbEnvs); |
|
Ice.StringSeqHelper.write(ostr, this.logs); |
|
ostr.writeString(this.description); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.adapters = IceGrid.AdapterDescriptorSeqHelper.read(istr); |
|
this.propertySet = IceGrid.PropertySetDescriptor.read(istr, this.propertySet); |
|
this.dbEnvs = IceGrid.DbEnvDescriptorSeqHelper.read(istr); |
|
this.logs = Ice.StringSeqHelper.read(istr); |
|
this.description = istr.readString(); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.CommunicatorDescriptor, iceC_IceGrid_CommunicatorDescriptor_ids[1], false); |
|
|
|
/** |
|
* A distribution descriptor defines an IcePatch2 server and the |
|
* directories to retrieve from the patch server. |
|
* |
|
**/ |
|
IceGrid.DistributionDescriptor = class |
|
{ |
|
constructor(icepatch = "", directories = null) |
|
{ |
|
this.icepatch = icepatch; |
|
this.directories = directories; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.icepatch); |
|
Ice.StringSeqHelper.write(ostr, this.directories); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.icepatch = istr.readString(); |
|
this.directories = Ice.StringSeqHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 2; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.DistributionDescriptor, true, true); |
|
|
|
const iceC_IceGrid_ServerDescriptor_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::CommunicatorDescriptor", |
|
"::IceGrid::ServerDescriptor" |
|
]; |
|
|
|
/** |
|
* An Ice server descriptor. |
|
* |
|
**/ |
|
IceGrid.ServerDescriptor = class extends IceGrid.CommunicatorDescriptor |
|
{ |
|
constructor(adapters, propertySet, dbEnvs, logs, description, id = "", exe = "", iceVersion = "", pwd = "", options = null, envs = null, activation = "", activationTimeout = "", deactivationTimeout = "", applicationDistrib = false, distrib = new IceGrid.DistributionDescriptor(), allocatable = false, user = "") |
|
{ |
|
super(adapters, propertySet, dbEnvs, logs, description); |
|
this.id = id; |
|
this.exe = exe; |
|
this.iceVersion = iceVersion; |
|
this.pwd = pwd; |
|
this.options = options; |
|
this.envs = envs; |
|
this.activation = activation; |
|
this.activationTimeout = activationTimeout; |
|
this.deactivationTimeout = deactivationTimeout; |
|
this.applicationDistrib = applicationDistrib; |
|
this.distrib = distrib; |
|
this.allocatable = allocatable; |
|
this.user = user; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
ostr.writeString(this.exe); |
|
ostr.writeString(this.iceVersion); |
|
ostr.writeString(this.pwd); |
|
Ice.StringSeqHelper.write(ostr, this.options); |
|
Ice.StringSeqHelper.write(ostr, this.envs); |
|
ostr.writeString(this.activation); |
|
ostr.writeString(this.activationTimeout); |
|
ostr.writeString(this.deactivationTimeout); |
|
ostr.writeBool(this.applicationDistrib); |
|
IceGrid.DistributionDescriptor.write(ostr, this.distrib); |
|
ostr.writeBool(this.allocatable); |
|
ostr.writeString(this.user); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.id = istr.readString(); |
|
this.exe = istr.readString(); |
|
this.iceVersion = istr.readString(); |
|
this.pwd = istr.readString(); |
|
this.options = Ice.StringSeqHelper.read(istr); |
|
this.envs = Ice.StringSeqHelper.read(istr); |
|
this.activation = istr.readString(); |
|
this.activationTimeout = istr.readString(); |
|
this.deactivationTimeout = istr.readString(); |
|
this.applicationDistrib = istr.readBool(); |
|
this.distrib = IceGrid.DistributionDescriptor.read(istr, this.distrib); |
|
this.allocatable = istr.readBool(); |
|
this.user = istr.readString(); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.ServerDescriptor, iceC_IceGrid_ServerDescriptor_ids[2], false); |
|
|
|
Slice.defineSequence(IceGrid, "ServerDescriptorSeqHelper", "Ice.ObjectHelper", false, "IceGrid.ServerDescriptor"); |
|
|
|
const iceC_IceGrid_ServiceDescriptor_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::CommunicatorDescriptor", |
|
"::IceGrid::ServiceDescriptor" |
|
]; |
|
|
|
/** |
|
* An IceBox service descriptor. |
|
* |
|
**/ |
|
IceGrid.ServiceDescriptor = class extends IceGrid.CommunicatorDescriptor |
|
{ |
|
constructor(adapters, propertySet, dbEnvs, logs, description, name = "", entry = "") |
|
{ |
|
super(adapters, propertySet, dbEnvs, logs, description); |
|
this.name = name; |
|
this.entry = entry; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.entry); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.entry = istr.readString(); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.ServiceDescriptor, iceC_IceGrid_ServiceDescriptor_ids[2], false); |
|
|
|
Slice.defineSequence(IceGrid, "ServiceDescriptorSeqHelper", "Ice.ObjectHelper", false, "IceGrid.ServiceDescriptor"); |
|
|
|
/** |
|
* A server template instance descriptor. |
|
* |
|
**/ |
|
IceGrid.ServerInstanceDescriptor = class |
|
{ |
|
constructor(template = "", parameterValues = null, propertySet = new IceGrid.PropertySetDescriptor(), servicePropertySets = null) |
|
{ |
|
this.template = template; |
|
this.parameterValues = parameterValues; |
|
this.propertySet = propertySet; |
|
this.servicePropertySets = servicePropertySets; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.template); |
|
IceGrid.StringStringDictHelper.write(ostr, this.parameterValues); |
|
IceGrid.PropertySetDescriptor.write(ostr, this.propertySet); |
|
IceGrid.PropertySetDescriptorDictHelper.write(ostr, this.servicePropertySets); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.template = istr.readString(); |
|
this.parameterValues = IceGrid.StringStringDictHelper.read(istr); |
|
this.propertySet = IceGrid.PropertySetDescriptor.read(istr, this.propertySet); |
|
this.servicePropertySets = IceGrid.PropertySetDescriptorDictHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 5; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ServerInstanceDescriptor, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "ServerInstanceDescriptorSeqHelper", "IceGrid.ServerInstanceDescriptor", false); |
|
|
|
/** |
|
* A template descriptor for server or service templates. |
|
* |
|
**/ |
|
IceGrid.TemplateDescriptor = class |
|
{ |
|
constructor(descriptor = null, parameters = null, parameterDefaults = null) |
|
{ |
|
this.descriptor = descriptor; |
|
this.parameters = parameters; |
|
this.parameterDefaults = parameterDefaults; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeValue(this.descriptor); |
|
Ice.StringSeqHelper.write(ostr, this.parameters); |
|
IceGrid.StringStringDictHelper.write(ostr, this.parameterDefaults); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
istr.readValue(obj => this.descriptor = obj, IceGrid.CommunicatorDescriptor); |
|
this.parameters = Ice.StringSeqHelper.read(istr); |
|
this.parameterDefaults = IceGrid.StringStringDictHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 3; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.TemplateDescriptor, false, true); |
|
|
|
Slice.defineDictionary(IceGrid, "TemplateDescriptorDict", "TemplateDescriptorDictHelper", "Ice.StringHelper", "IceGrid.TemplateDescriptor", false, undefined, undefined); |
|
|
|
/** |
|
* A service template instance descriptor. |
|
* |
|
**/ |
|
IceGrid.ServiceInstanceDescriptor = class |
|
{ |
|
constructor(template = "", parameterValues = null, descriptor = null, propertySet = new IceGrid.PropertySetDescriptor()) |
|
{ |
|
this.template = template; |
|
this.parameterValues = parameterValues; |
|
this.descriptor = descriptor; |
|
this.propertySet = propertySet; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.template); |
|
IceGrid.StringStringDictHelper.write(ostr, this.parameterValues); |
|
ostr.writeValue(this.descriptor); |
|
IceGrid.PropertySetDescriptor.write(ostr, this.propertySet); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.template = istr.readString(); |
|
this.parameterValues = IceGrid.StringStringDictHelper.read(istr); |
|
istr.readValue(obj => this.descriptor = obj, IceGrid.ServiceDescriptor); |
|
this.propertySet = IceGrid.PropertySetDescriptor.read(istr, this.propertySet); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 5; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ServiceInstanceDescriptor, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "ServiceInstanceDescriptorSeqHelper", "IceGrid.ServiceInstanceDescriptor", false); |
|
|
|
const iceC_IceGrid_IceBoxDescriptor_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::CommunicatorDescriptor", |
|
"::IceGrid::IceBoxDescriptor", |
|
"::IceGrid::ServerDescriptor" |
|
]; |
|
|
|
/** |
|
* An IceBox server descriptor. |
|
* |
|
**/ |
|
IceGrid.IceBoxDescriptor = class extends IceGrid.ServerDescriptor |
|
{ |
|
constructor(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user, services = null) |
|
{ |
|
super(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user); |
|
this.services = services; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
IceGrid.ServiceInstanceDescriptorSeqHelper.write(ostr, this.services); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.services = IceGrid.ServiceInstanceDescriptorSeqHelper.read(istr); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.IceBoxDescriptor, iceC_IceGrid_IceBoxDescriptor_ids[2], false); |
|
|
|
/** |
|
* A node descriptor. |
|
* |
|
**/ |
|
IceGrid.NodeDescriptor = class |
|
{ |
|
constructor(variables = null, serverInstances = null, servers = null, loadFactor = "", description = "", propertySets = null) |
|
{ |
|
this.variables = variables; |
|
this.serverInstances = serverInstances; |
|
this.servers = servers; |
|
this.loadFactor = loadFactor; |
|
this.description = description; |
|
this.propertySets = propertySets; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
IceGrid.StringStringDictHelper.write(ostr, this.variables); |
|
IceGrid.ServerInstanceDescriptorSeqHelper.write(ostr, this.serverInstances); |
|
IceGrid.ServerDescriptorSeqHelper.write(ostr, this.servers); |
|
ostr.writeString(this.loadFactor); |
|
ostr.writeString(this.description); |
|
IceGrid.PropertySetDescriptorDictHelper.write(ostr, this.propertySets); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.variables = IceGrid.StringStringDictHelper.read(istr); |
|
this.serverInstances = IceGrid.ServerInstanceDescriptorSeqHelper.read(istr); |
|
this.servers = IceGrid.ServerDescriptorSeqHelper.read(istr); |
|
this.loadFactor = istr.readString(); |
|
this.description = istr.readString(); |
|
this.propertySets = IceGrid.PropertySetDescriptorDictHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 6; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.NodeDescriptor, false, true); |
|
|
|
Slice.defineDictionary(IceGrid, "NodeDescriptorDict", "NodeDescriptorDictHelper", "Ice.StringHelper", "IceGrid.NodeDescriptor", false, undefined, undefined); |
|
|
|
const iceC_IceGrid_LoadBalancingPolicy_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::LoadBalancingPolicy" |
|
]; |
|
|
|
/** |
|
* A base class for load balancing policies. |
|
* |
|
**/ |
|
IceGrid.LoadBalancingPolicy = class extends Ice.Value |
|
{ |
|
constructor(nReplicas = "") |
|
{ |
|
super(); |
|
this.nReplicas = nReplicas; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.nReplicas); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.nReplicas = istr.readString(); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.LoadBalancingPolicy, iceC_IceGrid_LoadBalancingPolicy_ids[1], false); |
|
|
|
const iceC_IceGrid_RandomLoadBalancingPolicy_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::LoadBalancingPolicy", |
|
"::IceGrid::RandomLoadBalancingPolicy" |
|
]; |
|
|
|
/** |
|
* Random load balancing policy. |
|
* |
|
**/ |
|
IceGrid.RandomLoadBalancingPolicy = class extends IceGrid.LoadBalancingPolicy |
|
{ |
|
constructor(nReplicas) |
|
{ |
|
super(nReplicas); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.RandomLoadBalancingPolicy, iceC_IceGrid_RandomLoadBalancingPolicy_ids[2], false); |
|
|
|
const iceC_IceGrid_OrderedLoadBalancingPolicy_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::LoadBalancingPolicy", |
|
"::IceGrid::OrderedLoadBalancingPolicy" |
|
]; |
|
|
|
/** |
|
* Ordered load balancing policy. |
|
* |
|
**/ |
|
IceGrid.OrderedLoadBalancingPolicy = class extends IceGrid.LoadBalancingPolicy |
|
{ |
|
constructor(nReplicas) |
|
{ |
|
super(nReplicas); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.OrderedLoadBalancingPolicy, iceC_IceGrid_OrderedLoadBalancingPolicy_ids[2], false); |
|
|
|
const iceC_IceGrid_RoundRobinLoadBalancingPolicy_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::LoadBalancingPolicy", |
|
"::IceGrid::RoundRobinLoadBalancingPolicy" |
|
]; |
|
|
|
/** |
|
* Round robin load balancing policy. |
|
* |
|
**/ |
|
IceGrid.RoundRobinLoadBalancingPolicy = class extends IceGrid.LoadBalancingPolicy |
|
{ |
|
constructor(nReplicas) |
|
{ |
|
super(nReplicas); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.RoundRobinLoadBalancingPolicy, iceC_IceGrid_RoundRobinLoadBalancingPolicy_ids[2], false); |
|
|
|
const iceC_IceGrid_AdaptiveLoadBalancingPolicy_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::AdaptiveLoadBalancingPolicy", |
|
"::IceGrid::LoadBalancingPolicy" |
|
]; |
|
|
|
/** |
|
* Adaptive load balancing policy. |
|
* |
|
**/ |
|
IceGrid.AdaptiveLoadBalancingPolicy = class extends IceGrid.LoadBalancingPolicy |
|
{ |
|
constructor(nReplicas, loadSample = "") |
|
{ |
|
super(nReplicas); |
|
this.loadSample = loadSample; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.loadSample); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.loadSample = istr.readString(); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.AdaptiveLoadBalancingPolicy, iceC_IceGrid_AdaptiveLoadBalancingPolicy_ids[1], false); |
|
|
|
/** |
|
* A replica group descriptor. |
|
* |
|
**/ |
|
IceGrid.ReplicaGroupDescriptor = class |
|
{ |
|
constructor(id = "", loadBalancing = null, proxyOptions = "", objects = null, description = "", filter = "") |
|
{ |
|
this.id = id; |
|
this.loadBalancing = loadBalancing; |
|
this.proxyOptions = proxyOptions; |
|
this.objects = objects; |
|
this.description = description; |
|
this.filter = filter; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
ostr.writeValue(this.loadBalancing); |
|
ostr.writeString(this.proxyOptions); |
|
IceGrid.ObjectDescriptorSeqHelper.write(ostr, this.objects); |
|
ostr.writeString(this.description); |
|
ostr.writeString(this.filter); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.id = istr.readString(); |
|
istr.readValue(obj => this.loadBalancing = obj, IceGrid.LoadBalancingPolicy); |
|
this.proxyOptions = istr.readString(); |
|
this.objects = IceGrid.ObjectDescriptorSeqHelper.read(istr); |
|
this.description = istr.readString(); |
|
this.filter = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 6; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ReplicaGroupDescriptor, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "ReplicaGroupDescriptorSeqHelper", "IceGrid.ReplicaGroupDescriptor", false); |
|
|
|
/** |
|
* An application descriptor. |
|
* |
|
**/ |
|
IceGrid.ApplicationDescriptor = class |
|
{ |
|
constructor(name = "", variables = null, replicaGroups = null, serverTemplates = null, serviceTemplates = null, nodes = null, distrib = new IceGrid.DistributionDescriptor(), description = "", propertySets = null) |
|
{ |
|
this.name = name; |
|
this.variables = variables; |
|
this.replicaGroups = replicaGroups; |
|
this.serverTemplates = serverTemplates; |
|
this.serviceTemplates = serviceTemplates; |
|
this.nodes = nodes; |
|
this.distrib = distrib; |
|
this.description = description; |
|
this.propertySets = propertySets; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
IceGrid.StringStringDictHelper.write(ostr, this.variables); |
|
IceGrid.ReplicaGroupDescriptorSeqHelper.write(ostr, this.replicaGroups); |
|
IceGrid.TemplateDescriptorDictHelper.write(ostr, this.serverTemplates); |
|
IceGrid.TemplateDescriptorDictHelper.write(ostr, this.serviceTemplates); |
|
IceGrid.NodeDescriptorDictHelper.write(ostr, this.nodes); |
|
IceGrid.DistributionDescriptor.write(ostr, this.distrib); |
|
ostr.writeString(this.description); |
|
IceGrid.PropertySetDescriptorDictHelper.write(ostr, this.propertySets); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.variables = IceGrid.StringStringDictHelper.read(istr); |
|
this.replicaGroups = IceGrid.ReplicaGroupDescriptorSeqHelper.read(istr); |
|
this.serverTemplates = IceGrid.TemplateDescriptorDictHelper.read(istr); |
|
this.serviceTemplates = IceGrid.TemplateDescriptorDictHelper.read(istr); |
|
this.nodes = IceGrid.NodeDescriptorDictHelper.read(istr); |
|
this.distrib = IceGrid.DistributionDescriptor.read(istr, this.distrib); |
|
this.description = istr.readString(); |
|
this.propertySets = IceGrid.PropertySetDescriptorDictHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 10; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ApplicationDescriptor, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "ApplicationDescriptorSeqHelper", "IceGrid.ApplicationDescriptor", false); |
|
|
|
const iceC_IceGrid_BoxedString_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::BoxedString" |
|
]; |
|
|
|
/** |
|
* A "boxed" string. |
|
* |
|
**/ |
|
IceGrid.BoxedString = class extends Ice.Value |
|
{ |
|
constructor(value = "") |
|
{ |
|
super(); |
|
this.value = value; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.value); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.value = istr.readString(); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.BoxedString, iceC_IceGrid_BoxedString_ids[1], false); |
|
|
|
/** |
|
* A node update descriptor to describe the updates to apply to a |
|
* node of a deployed application. |
|
* |
|
**/ |
|
IceGrid.NodeUpdateDescriptor = class |
|
{ |
|
constructor(name = "", description = null, variables = null, removeVariables = null, propertySets = null, removePropertySets = null, serverInstances = null, servers = null, removeServers = null, loadFactor = null) |
|
{ |
|
this.name = name; |
|
this.description = description; |
|
this.variables = variables; |
|
this.removeVariables = removeVariables; |
|
this.propertySets = propertySets; |
|
this.removePropertySets = removePropertySets; |
|
this.serverInstances = serverInstances; |
|
this.servers = servers; |
|
this.removeServers = removeServers; |
|
this.loadFactor = loadFactor; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeValue(this.description); |
|
IceGrid.StringStringDictHelper.write(ostr, this.variables); |
|
Ice.StringSeqHelper.write(ostr, this.removeVariables); |
|
IceGrid.PropertySetDescriptorDictHelper.write(ostr, this.propertySets); |
|
Ice.StringSeqHelper.write(ostr, this.removePropertySets); |
|
IceGrid.ServerInstanceDescriptorSeqHelper.write(ostr, this.serverInstances); |
|
IceGrid.ServerDescriptorSeqHelper.write(ostr, this.servers); |
|
Ice.StringSeqHelper.write(ostr, this.removeServers); |
|
ostr.writeValue(this.loadFactor); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
istr.readValue(obj => this.description = obj, IceGrid.BoxedString); |
|
this.variables = IceGrid.StringStringDictHelper.read(istr); |
|
this.removeVariables = Ice.StringSeqHelper.read(istr); |
|
this.propertySets = IceGrid.PropertySetDescriptorDictHelper.read(istr); |
|
this.removePropertySets = Ice.StringSeqHelper.read(istr); |
|
this.serverInstances = IceGrid.ServerInstanceDescriptorSeqHelper.read(istr); |
|
this.servers = IceGrid.ServerDescriptorSeqHelper.read(istr); |
|
this.removeServers = Ice.StringSeqHelper.read(istr); |
|
istr.readValue(obj => this.loadFactor = obj, IceGrid.BoxedString); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 10; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.NodeUpdateDescriptor, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "NodeUpdateDescriptorSeqHelper", "IceGrid.NodeUpdateDescriptor", false); |
|
|
|
const iceC_IceGrid_BoxedDistributionDescriptor_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::BoxedDistributionDescriptor" |
|
]; |
|
|
|
/** |
|
* A "boxed" distribution descriptor. |
|
* |
|
**/ |
|
IceGrid.BoxedDistributionDescriptor = class extends Ice.Value |
|
{ |
|
constructor(value = new IceGrid.DistributionDescriptor()) |
|
{ |
|
super(); |
|
this.value = value; |
|
} |
|
|
|
_iceWriteMemberImpl(ostr) |
|
{ |
|
IceGrid.DistributionDescriptor.write(ostr, this.value); |
|
} |
|
|
|
_iceReadMemberImpl(istr) |
|
{ |
|
this.value = IceGrid.DistributionDescriptor.read(istr, this.value); |
|
} |
|
}; |
|
|
|
Slice.defineValue(IceGrid.BoxedDistributionDescriptor, iceC_IceGrid_BoxedDistributionDescriptor_ids[1], false); |
|
|
|
/** |
|
* An application update descriptor to describe the updates to apply |
|
* to a deployed application. |
|
* |
|
**/ |
|
IceGrid.ApplicationUpdateDescriptor = class |
|
{ |
|
constructor(name = "", description = null, distrib = null, variables = null, removeVariables = null, propertySets = null, removePropertySets = null, replicaGroups = null, removeReplicaGroups = null, serverTemplates = null, removeServerTemplates = null, serviceTemplates = null, removeServiceTemplates = null, nodes = null, removeNodes = null) |
|
{ |
|
this.name = name; |
|
this.description = description; |
|
this.distrib = distrib; |
|
this.variables = variables; |
|
this.removeVariables = removeVariables; |
|
this.propertySets = propertySets; |
|
this.removePropertySets = removePropertySets; |
|
this.replicaGroups = replicaGroups; |
|
this.removeReplicaGroups = removeReplicaGroups; |
|
this.serverTemplates = serverTemplates; |
|
this.removeServerTemplates = removeServerTemplates; |
|
this.serviceTemplates = serviceTemplates; |
|
this.removeServiceTemplates = removeServiceTemplates; |
|
this.nodes = nodes; |
|
this.removeNodes = removeNodes; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeValue(this.description); |
|
ostr.writeValue(this.distrib); |
|
IceGrid.StringStringDictHelper.write(ostr, this.variables); |
|
Ice.StringSeqHelper.write(ostr, this.removeVariables); |
|
IceGrid.PropertySetDescriptorDictHelper.write(ostr, this.propertySets); |
|
Ice.StringSeqHelper.write(ostr, this.removePropertySets); |
|
IceGrid.ReplicaGroupDescriptorSeqHelper.write(ostr, this.replicaGroups); |
|
Ice.StringSeqHelper.write(ostr, this.removeReplicaGroups); |
|
IceGrid.TemplateDescriptorDictHelper.write(ostr, this.serverTemplates); |
|
Ice.StringSeqHelper.write(ostr, this.removeServerTemplates); |
|
IceGrid.TemplateDescriptorDictHelper.write(ostr, this.serviceTemplates); |
|
Ice.StringSeqHelper.write(ostr, this.removeServiceTemplates); |
|
IceGrid.NodeUpdateDescriptorSeqHelper.write(ostr, this.nodes); |
|
Ice.StringSeqHelper.write(ostr, this.removeNodes); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
istr.readValue(obj => this.description = obj, IceGrid.BoxedString); |
|
istr.readValue(obj => this.distrib = obj, IceGrid.BoxedDistributionDescriptor); |
|
this.variables = IceGrid.StringStringDictHelper.read(istr); |
|
this.removeVariables = Ice.StringSeqHelper.read(istr); |
|
this.propertySets = IceGrid.PropertySetDescriptorDictHelper.read(istr); |
|
this.removePropertySets = Ice.StringSeqHelper.read(istr); |
|
this.replicaGroups = IceGrid.ReplicaGroupDescriptorSeqHelper.read(istr); |
|
this.removeReplicaGroups = Ice.StringSeqHelper.read(istr); |
|
this.serverTemplates = IceGrid.TemplateDescriptorDictHelper.read(istr); |
|
this.removeServerTemplates = Ice.StringSeqHelper.read(istr); |
|
this.serviceTemplates = IceGrid.TemplateDescriptorDictHelper.read(istr); |
|
this.removeServiceTemplates = Ice.StringSeqHelper.read(istr); |
|
this.nodes = IceGrid.NodeUpdateDescriptorSeqHelper.read(istr); |
|
this.removeNodes = Ice.StringSeqHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 15; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ApplicationUpdateDescriptor, false, true); |
|
|
|
}()); |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
// |
|
// Ice version 3.7.3 |
|
// |
|
// <auto-generated> |
|
// |
|
// Generated from file `Exception.ice' |
|
// |
|
// Warning: do not edit this file. |
|
// |
|
// </auto-generated> |
|
// |
|
|
|
/* eslint-disable */ |
|
/* jshint ignore: start */ |
|
|
|
|
|
/** |
|
* This exception is raised if an application does not exist. |
|
* |
|
**/ |
|
IceGrid.ApplicationNotExistException = class extends Ice.UserException |
|
{ |
|
constructor(name = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.name = name; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ApplicationNotExistException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ApplicationNotExistException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.name = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a server does not exist. |
|
* |
|
**/ |
|
IceGrid.ServerNotExistException = class extends Ice.UserException |
|
{ |
|
constructor(id = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.id = id; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ServerNotExistException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ServerNotExistException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.id = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a server failed to start. |
|
* |
|
**/ |
|
IceGrid.ServerStartException = class extends Ice.UserException |
|
{ |
|
constructor(id = "", reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.id = id; |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ServerStartException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ServerStartException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.id = istr.readString(); |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a server failed to stop. |
|
* |
|
**/ |
|
IceGrid.ServerStopException = class extends Ice.UserException |
|
{ |
|
constructor(id = "", reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.id = id; |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ServerStopException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ServerStopException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.id = istr.readString(); |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if an adapter does not exist. |
|
* |
|
**/ |
|
IceGrid.AdapterNotExistException = class extends Ice.UserException |
|
{ |
|
constructor(id = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.id = id; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::AdapterNotExistException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.AdapterNotExistException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.id = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if an object already exists. |
|
* |
|
**/ |
|
IceGrid.ObjectExistsException = class extends Ice.UserException |
|
{ |
|
constructor(id = new Ice.Identity(), _cause = "") |
|
{ |
|
super(_cause); |
|
this.id = id; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ObjectExistsException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ObjectExistsException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
Ice.Identity.write(ostr, this.id); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.id = Ice.Identity.read(istr, this.id); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if an object is not registered. |
|
* |
|
**/ |
|
IceGrid.ObjectNotRegisteredException = class extends Ice.UserException |
|
{ |
|
constructor(id = new Ice.Identity(), _cause = "") |
|
{ |
|
super(_cause); |
|
this.id = id; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ObjectNotRegisteredException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ObjectNotRegisteredException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
Ice.Identity.write(ostr, this.id); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.id = Ice.Identity.read(istr, this.id); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a node does not exist. |
|
* |
|
**/ |
|
IceGrid.NodeNotExistException = class extends Ice.UserException |
|
{ |
|
constructor(name = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.name = name; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::NodeNotExistException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.NodeNotExistException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.name = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a registry does not exist. |
|
* |
|
**/ |
|
IceGrid.RegistryNotExistException = class extends Ice.UserException |
|
{ |
|
constructor(name = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.name = name; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::RegistryNotExistException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.RegistryNotExistException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.name = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* An exception for deployment errors. |
|
* |
|
**/ |
|
IceGrid.DeploymentException = class extends Ice.UserException |
|
{ |
|
constructor(reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::DeploymentException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.DeploymentException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a node could not be reached. |
|
* |
|
**/ |
|
IceGrid.NodeUnreachableException = class extends Ice.UserException |
|
{ |
|
constructor(name = "", reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.name = name; |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::NodeUnreachableException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.NodeUnreachableException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a server could not be reached. |
|
* |
|
**/ |
|
IceGrid.ServerUnreachableException = class extends Ice.UserException |
|
{ |
|
constructor(name = "", reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.name = name; |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ServerUnreachableException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ServerUnreachableException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a registry could not be reached. |
|
* |
|
**/ |
|
IceGrid.RegistryUnreachableException = class extends Ice.UserException |
|
{ |
|
constructor(name = "", reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.name = name; |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::RegistryUnreachableException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.RegistryUnreachableException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if an unknown signal was sent to |
|
* to a server. |
|
* |
|
**/ |
|
IceGrid.BadSignalException = class extends Ice.UserException |
|
{ |
|
constructor(reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::BadSignalException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.BadSignalException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a patch failed. |
|
* |
|
**/ |
|
IceGrid.PatchException = class extends Ice.UserException |
|
{ |
|
constructor(reasons = null, _cause = "") |
|
{ |
|
super(_cause); |
|
this.reasons = reasons; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::PatchException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.PatchException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
Ice.StringSeqHelper.write(ostr, this.reasons); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.reasons = Ice.StringSeqHelper.read(istr); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a registry lock wasn't |
|
* acquired or is already held by a session. |
|
* |
|
**/ |
|
IceGrid.AccessDeniedException = class extends Ice.UserException |
|
{ |
|
constructor(lockUserId = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.lockUserId = lockUserId; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::AccessDeniedException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.AccessDeniedException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.lockUserId); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.lockUserId = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if the allocation of an object failed. |
|
* |
|
**/ |
|
IceGrid.AllocationException = class extends Ice.UserException |
|
{ |
|
constructor(reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::AllocationException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.AllocationException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if the request to allocate an object times |
|
* out. |
|
* |
|
**/ |
|
IceGrid.AllocationTimeoutException = class extends IceGrid.AllocationException |
|
{ |
|
constructor(reason, _cause = "") |
|
{ |
|
super(reason, _cause); |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return IceGrid.AllocationException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::AllocationTimeoutException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.AllocationTimeoutException; |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a client is denied the ability to create |
|
* a session with IceGrid. |
|
* |
|
**/ |
|
IceGrid.PermissionDeniedException = class extends Ice.UserException |
|
{ |
|
constructor(reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::PermissionDeniedException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.PermissionDeniedException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if an observer is already registered with |
|
* the registry. |
|
* |
|
* @see AdminSession#setObservers |
|
* @see AdminSession#setObserversByIdentity |
|
* |
|
**/ |
|
IceGrid.ObserverAlreadyRegisteredException = class extends Ice.UserException |
|
{ |
|
constructor(id = new Ice.Identity(), _cause = "") |
|
{ |
|
super(_cause); |
|
this.id = id; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ObserverAlreadyRegisteredException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ObserverAlreadyRegisteredException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
Ice.Identity.write(ostr, this.id); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.id = Ice.Identity.read(istr, this.id); |
|
} |
|
}; |
|
|
|
/** |
|
* This exception is raised if a file is not available. |
|
* |
|
* @see AdminSession#openServerStdOut |
|
* @see AdminSession#openServerStdErr |
|
* @see AdminSession#openNodeStdOut |
|
* @see AdminSession#openNodeStdErr |
|
* @see AdminSession#openRegistryStdOut |
|
* @see AdminSession#openRegistryStdErr |
|
* |
|
**/ |
|
IceGrid.FileNotAvailableException = class extends Ice.UserException |
|
{ |
|
constructor(reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::FileNotAvailableException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.FileNotAvailableException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
}()); |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
// |
|
// Ice version 3.7.3 |
|
// |
|
// <auto-generated> |
|
// |
|
// Generated from file `Admin.ice' |
|
// |
|
// Warning: do not edit this file. |
|
// |
|
// </auto-generated> |
|
// |
|
|
|
/* eslint-disable */ |
|
/* jshint ignore: start */ |
|
|
|
|
|
/** |
|
* An enumeration representing the state of the server. |
|
* |
|
**/ |
|
IceGrid.ServerState = Slice.defineEnum([ |
|
['Inactive', 0], ['Activating', 1], ['ActivationTimedOut', 2], ['Active', 3], ['Deactivating', 4], |
|
['Destroying', 5], ['Destroyed', 6]]); |
|
|
|
Slice.defineDictionary(IceGrid, "StringObjectProxyDict", "StringObjectProxyDictHelper", "Ice.StringHelper", "Ice.ObjectPrx", false, undefined, undefined); |
|
|
|
/** |
|
* Information about an Ice object. |
|
* |
|
**/ |
|
IceGrid.ObjectInfo = class |
|
{ |
|
constructor(proxy = null, type = "") |
|
{ |
|
this.proxy = proxy; |
|
this.type = type; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeProxy(this.proxy); |
|
ostr.writeString(this.type); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.proxy = istr.readProxy(); |
|
this.type = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 3; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ObjectInfo, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "ObjectInfoSeqHelper", "IceGrid.ObjectInfo", false); |
|
|
|
/** |
|
* Information about an adapter registered with the IceGrid registry. |
|
* |
|
**/ |
|
IceGrid.AdapterInfo = class |
|
{ |
|
constructor(id = "", proxy = null, replicaGroupId = "") |
|
{ |
|
this.id = id; |
|
this.proxy = proxy; |
|
this.replicaGroupId = replicaGroupId; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
ostr.writeProxy(this.proxy); |
|
ostr.writeString(this.replicaGroupId); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.id = istr.readString(); |
|
this.proxy = istr.readProxy(); |
|
this.replicaGroupId = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 4; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.AdapterInfo, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "AdapterInfoSeqHelper", "IceGrid.AdapterInfo", false); |
|
|
|
/** |
|
* Information about a server managed by an IceGrid node. |
|
* |
|
**/ |
|
IceGrid.ServerInfo = class |
|
{ |
|
constructor(application = "", uuid = "", revision = 0, node = "", descriptor = null, sessionId = "") |
|
{ |
|
this.application = application; |
|
this.uuid = uuid; |
|
this.revision = revision; |
|
this.node = node; |
|
this.descriptor = descriptor; |
|
this.sessionId = sessionId; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.application); |
|
ostr.writeString(this.uuid); |
|
ostr.writeInt(this.revision); |
|
ostr.writeString(this.node); |
|
ostr.writeValue(this.descriptor); |
|
ostr.writeString(this.sessionId); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.application = istr.readString(); |
|
this.uuid = istr.readString(); |
|
this.revision = istr.readInt(); |
|
this.node = istr.readString(); |
|
istr.readValue(obj => this.descriptor = obj, IceGrid.ServerDescriptor); |
|
this.sessionId = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 9; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ServerInfo, false, true); |
|
|
|
/** |
|
* Information about an IceGrid node. |
|
* |
|
**/ |
|
IceGrid.NodeInfo = class |
|
{ |
|
constructor(name = "", os = "", hostname = "", release = "", version = "", machine = "", nProcessors = 0, dataDir = "") |
|
{ |
|
this.name = name; |
|
this.os = os; |
|
this.hostname = hostname; |
|
this.release = release; |
|
this.version = version; |
|
this.machine = machine; |
|
this.nProcessors = nProcessors; |
|
this.dataDir = dataDir; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.os); |
|
ostr.writeString(this.hostname); |
|
ostr.writeString(this.release); |
|
ostr.writeString(this.version); |
|
ostr.writeString(this.machine); |
|
ostr.writeInt(this.nProcessors); |
|
ostr.writeString(this.dataDir); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.os = istr.readString(); |
|
this.hostname = istr.readString(); |
|
this.release = istr.readString(); |
|
this.version = istr.readString(); |
|
this.machine = istr.readString(); |
|
this.nProcessors = istr.readInt(); |
|
this.dataDir = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 11; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.NodeInfo, true, true); |
|
|
|
/** |
|
* Information about an IceGrid registry replica. |
|
* |
|
**/ |
|
IceGrid.RegistryInfo = class |
|
{ |
|
constructor(name = "", hostname = "") |
|
{ |
|
this.name = name; |
|
this.hostname = hostname; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.name); |
|
ostr.writeString(this.hostname); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.name = istr.readString(); |
|
this.hostname = istr.readString(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 2; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.RegistryInfo, true, true); |
|
|
|
Slice.defineSequence(IceGrid, "RegistryInfoSeqHelper", "IceGrid.RegistryInfo", false); |
|
|
|
/** |
|
* Information about the load of a node. |
|
* |
|
**/ |
|
IceGrid.LoadInfo = class |
|
{ |
|
constructor(avg1 = 0.0, avg5 = 0.0, avg15 = 0.0) |
|
{ |
|
this.avg1 = avg1; |
|
this.avg5 = avg5; |
|
this.avg15 = avg15; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeFloat(this.avg1); |
|
ostr.writeFloat(this.avg5); |
|
ostr.writeFloat(this.avg15); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.avg1 = istr.readFloat(); |
|
this.avg5 = istr.readFloat(); |
|
this.avg15 = istr.readFloat(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 12; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.LoadInfo, false, false); |
|
|
|
/** |
|
* Information about an IceGrid application. |
|
* |
|
**/ |
|
IceGrid.ApplicationInfo = class |
|
{ |
|
constructor(uuid = "", createTime = new Ice.Long(0, 0), createUser = "", updateTime = new Ice.Long(0, 0), updateUser = "", revision = 0, descriptor = new IceGrid.ApplicationDescriptor()) |
|
{ |
|
this.uuid = uuid; |
|
this.createTime = createTime; |
|
this.createUser = createUser; |
|
this.updateTime = updateTime; |
|
this.updateUser = updateUser; |
|
this.revision = revision; |
|
this.descriptor = descriptor; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.uuid); |
|
ostr.writeLong(this.createTime); |
|
ostr.writeString(this.createUser); |
|
ostr.writeLong(this.updateTime); |
|
ostr.writeString(this.updateUser); |
|
ostr.writeInt(this.revision); |
|
IceGrid.ApplicationDescriptor.write(ostr, this.descriptor); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.uuid = istr.readString(); |
|
this.createTime = istr.readLong(); |
|
this.createUser = istr.readString(); |
|
this.updateTime = istr.readLong(); |
|
this.updateUser = istr.readString(); |
|
this.revision = istr.readInt(); |
|
this.descriptor = IceGrid.ApplicationDescriptor.read(istr, this.descriptor); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 33; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ApplicationInfo, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "ApplicationInfoSeqHelper", "IceGrid.ApplicationInfo", false); |
|
|
|
/** |
|
* Information about updates to an IceGrid application. |
|
* |
|
**/ |
|
IceGrid.ApplicationUpdateInfo = class |
|
{ |
|
constructor(updateTime = new Ice.Long(0, 0), updateUser = "", revision = 0, descriptor = new IceGrid.ApplicationUpdateDescriptor()) |
|
{ |
|
this.updateTime = updateTime; |
|
this.updateUser = updateUser; |
|
this.revision = revision; |
|
this.descriptor = descriptor; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeLong(this.updateTime); |
|
ostr.writeString(this.updateUser); |
|
ostr.writeInt(this.revision); |
|
IceGrid.ApplicationUpdateDescriptor.write(ostr, this.descriptor); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.updateTime = istr.readLong(); |
|
this.updateUser = istr.readString(); |
|
this.revision = istr.readInt(); |
|
this.descriptor = IceGrid.ApplicationUpdateDescriptor.read(istr, this.descriptor); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 28; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ApplicationUpdateInfo, false, true); |
|
|
|
const iceC_IceGrid_Admin_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::Admin" |
|
]; |
|
|
|
/** |
|
* The IceGrid administrative interface. |
|
* <p class="Warning">Allowing access to this interface |
|
* is a security risk! Please see the IceGrid documentation |
|
* for further information. |
|
* |
|
**/ |
|
IceGrid.Admin = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.AdminPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.Admin, IceGrid.AdminPrx, iceC_IceGrid_Admin_ids, 1, |
|
{ |
|
"addApplication": [, , , , , [[IceGrid.ApplicationDescriptor]], , |
|
[ |
|
IceGrid.AccessDeniedException, |
|
IceGrid.DeploymentException |
|
], true, ], |
|
"syncApplication": [, , , , , [[IceGrid.ApplicationDescriptor]], , |
|
[ |
|
IceGrid.AccessDeniedException, |
|
IceGrid.ApplicationNotExistException, |
|
IceGrid.DeploymentException |
|
], true, ], |
|
"updateApplication": [, , , , , [[IceGrid.ApplicationUpdateDescriptor]], , |
|
[ |
|
IceGrid.AccessDeniedException, |
|
IceGrid.ApplicationNotExistException, |
|
IceGrid.DeploymentException |
|
], true, ], |
|
"syncApplicationWithoutRestart": [, , , , , [[IceGrid.ApplicationDescriptor]], , |
|
[ |
|
IceGrid.AccessDeniedException, |
|
IceGrid.ApplicationNotExistException, |
|
IceGrid.DeploymentException |
|
], true, ], |
|
"updateApplicationWithoutRestart": [, , , , , [[IceGrid.ApplicationUpdateDescriptor]], , |
|
[ |
|
IceGrid.AccessDeniedException, |
|
IceGrid.ApplicationNotExistException, |
|
IceGrid.DeploymentException |
|
], true, ], |
|
"removeApplication": [, , , , , [[7]], , |
|
[ |
|
IceGrid.AccessDeniedException, |
|
IceGrid.ApplicationNotExistException, |
|
IceGrid.DeploymentException |
|
], , ], |
|
"instantiateServer": [, , , , , [[7], [7], [IceGrid.ServerInstanceDescriptor]], , |
|
[ |
|
IceGrid.AccessDeniedException, |
|
IceGrid.ApplicationNotExistException, |
|
IceGrid.DeploymentException |
|
], , ], |
|
"patchApplication": [, , , , , [[7], [1]], , |
|
[ |
|
IceGrid.ApplicationNotExistException, |
|
IceGrid.PatchException |
|
], , ], |
|
"getApplicationInfo": [, 2, 1, , [IceGrid.ApplicationInfo], [[7]], , |
|
[ |
|
IceGrid.ApplicationNotExistException |
|
], , true], |
|
"getDefaultApplicationDescriptor": [, 2, 1, , [IceGrid.ApplicationDescriptor], , , |
|
[ |
|
IceGrid.DeploymentException |
|
], , true], |
|
"getAllApplicationNames": [, 2, 1, , ["Ice.StringSeqHelper"], , , , , ], |
|
"getServerInfo": [, 2, 1, , [IceGrid.ServerInfo], [[7]], , |
|
[ |
|
IceGrid.ServerNotExistException |
|
], , true], |
|
"getServerState": [, 2, 1, , [IceGrid.ServerState._helper], [[7]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"getServerPid": [, 2, 1, , [3], [[7]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"getServerAdminCategory": [, 2, 2, , [7], , , , , ], |
|
"getServerAdmin": [, 2, 2, , [9], [[7]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"enableServer": [, 2, 2, , , [[7], [1]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"isServerEnabled": [, 2, 1, , [1], [[7]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"startServer": [, , , , , [[7]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException, |
|
IceGrid.ServerStartException |
|
], , ], |
|
"stopServer": [, , , , , [[7]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException, |
|
IceGrid.ServerStopException |
|
], , ], |
|
"patchServer": [, , , , , [[7], [1]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.PatchException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"sendSignal": [, , , , , [[7], [7]], , |
|
[ |
|
IceGrid.BadSignalException, |
|
IceGrid.DeploymentException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"getAllServerIds": [, 2, 1, , ["Ice.StringSeqHelper"], , , , , ], |
|
"getAdapterInfo": [, 2, 1, , ["IceGrid.AdapterInfoSeqHelper"], [[7]], , |
|
[ |
|
IceGrid.AdapterNotExistException |
|
], , ], |
|
"removeAdapter": [, , , , , [[7]], , |
|
[ |
|
IceGrid.AdapterNotExistException, |
|
IceGrid.DeploymentException |
|
], , ], |
|
"getAllAdapterIds": [, 2, 1, , ["Ice.StringSeqHelper"], , , , , ], |
|
"addObject": [, , , , , [[9]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.ObjectExistsException |
|
], , ], |
|
"updateObject": [, , , , , [[9]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.ObjectNotRegisteredException |
|
], , ], |
|
"addObjectWithType": [, , , , , [[9], [7]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.ObjectExistsException |
|
], , ], |
|
"removeObject": [, , , , , [[Ice.Identity]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.ObjectNotRegisteredException |
|
], , ], |
|
"getObjectInfo": [, 2, 1, , [IceGrid.ObjectInfo], [[Ice.Identity]], , |
|
[ |
|
IceGrid.ObjectNotRegisteredException |
|
], , ], |
|
"getObjectInfosByType": [, 2, 1, , ["IceGrid.ObjectInfoSeqHelper"], [[7]], , , , ], |
|
"getAllObjectInfos": [, 2, 1, , ["IceGrid.ObjectInfoSeqHelper"], [[7]], , , , ], |
|
"pingNode": [, 2, 1, , [1], [[7]], , |
|
[ |
|
IceGrid.NodeNotExistException |
|
], , ], |
|
"getNodeLoad": [, 2, 1, , [IceGrid.LoadInfo], [[7]], , |
|
[ |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"getNodeInfo": [, 2, 1, , [IceGrid.NodeInfo], [[7]], , |
|
[ |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"getNodeAdmin": [, 2, 2, , [9], [[7]], , |
|
[ |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"getNodeProcessorSocketCount": [, 2, 1, , [3], [[7]], , |
|
[ |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"shutdownNode": [, , , , , [[7]], , |
|
[ |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"getNodeHostname": [, 2, 1, , [7], [[7]], , |
|
[ |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"getAllNodeNames": [, 2, 1, , ["Ice.StringSeqHelper"], , , , , ], |
|
"pingRegistry": [, 2, 2, , [1], [[7]], , |
|
[ |
|
IceGrid.RegistryNotExistException |
|
], , ], |
|
"getRegistryInfo": [, 2, 2, , [IceGrid.RegistryInfo], [[7]], , |
|
[ |
|
IceGrid.RegistryNotExistException, |
|
IceGrid.RegistryUnreachableException |
|
], , ], |
|
"getRegistryAdmin": [, 2, 2, , [9], [[7]], , |
|
[ |
|
IceGrid.RegistryNotExistException |
|
], , ], |
|
"shutdownRegistry": [, 2, 2, , , [[7]], , |
|
[ |
|
IceGrid.RegistryNotExistException, |
|
IceGrid.RegistryUnreachableException |
|
], , ], |
|
"getAllRegistryNames": [, 2, 2, , ["Ice.StringSeqHelper"], , , , , ], |
|
"shutdown": [, , , , , , , , , ], |
|
"getSliceChecksums": [, 2, 1, , ["Ice.SliceChecksumDictHelper"], , , , , ] |
|
}); |
|
|
|
const iceC_IceGrid_FileIterator_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::FileIterator" |
|
]; |
|
|
|
/** |
|
* This interface provides access to IceGrid log file contents. |
|
* |
|
**/ |
|
IceGrid.FileIterator = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.FileIteratorPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.FileIterator, IceGrid.FileIteratorPrx, iceC_IceGrid_FileIterator_ids, 1, |
|
{ |
|
"read": [, , , , [1], [[3]], [["Ice.StringSeqHelper"]], |
|
[ |
|
IceGrid.FileNotAvailableException |
|
], , ], |
|
"destroy": [, , , , , , , , , ] |
|
}); |
|
|
|
/** |
|
* Dynamic information about the state of a server. |
|
* |
|
**/ |
|
IceGrid.ServerDynamicInfo = class |
|
{ |
|
constructor(id = "", state = IceGrid.ServerState.Inactive, pid = 0, enabled = false) |
|
{ |
|
this.id = id; |
|
this.state = state; |
|
this.pid = pid; |
|
this.enabled = enabled; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
IceGrid.ServerState._write(ostr, this.state); |
|
ostr.writeInt(this.pid); |
|
ostr.writeBool(this.enabled); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.id = istr.readString(); |
|
this.state = IceGrid.ServerState._read(istr); |
|
this.pid = istr.readInt(); |
|
this.enabled = istr.readBool(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 7; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.ServerDynamicInfo, true, true); |
|
|
|
Slice.defineSequence(IceGrid, "ServerDynamicInfoSeqHelper", "IceGrid.ServerDynamicInfo", false); |
|
|
|
/** |
|
* Dynamic information about the state of an adapter. |
|
* |
|
**/ |
|
IceGrid.AdapterDynamicInfo = class |
|
{ |
|
constructor(id = "", proxy = null) |
|
{ |
|
this.id = id; |
|
this.proxy = proxy; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
ostr.writeString(this.id); |
|
ostr.writeProxy(this.proxy); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.id = istr.readString(); |
|
this.proxy = istr.readProxy(); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 3; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.AdapterDynamicInfo, false, true); |
|
|
|
Slice.defineSequence(IceGrid, "AdapterDynamicInfoSeqHelper", "IceGrid.AdapterDynamicInfo", false); |
|
|
|
/** |
|
* Dynamic information about the state of a node. |
|
* |
|
**/ |
|
IceGrid.NodeDynamicInfo = class |
|
{ |
|
constructor(info = new IceGrid.NodeInfo(), servers = null, adapters = null) |
|
{ |
|
this.info = info; |
|
this.servers = servers; |
|
this.adapters = adapters; |
|
} |
|
|
|
_write(ostr) |
|
{ |
|
IceGrid.NodeInfo.write(ostr, this.info); |
|
IceGrid.ServerDynamicInfoSeqHelper.write(ostr, this.servers); |
|
IceGrid.AdapterDynamicInfoSeqHelper.write(ostr, this.adapters); |
|
} |
|
|
|
_read(istr) |
|
{ |
|
this.info = IceGrid.NodeInfo.read(istr, this.info); |
|
this.servers = IceGrid.ServerDynamicInfoSeqHelper.read(istr); |
|
this.adapters = IceGrid.AdapterDynamicInfoSeqHelper.read(istr); |
|
} |
|
|
|
static get minWireSize() |
|
{ |
|
return 13; |
|
} |
|
}; |
|
|
|
Slice.defineStruct(IceGrid.NodeDynamicInfo, false, true); |
|
|
|
const iceC_IceGrid_RegistryObserver_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::RegistryObserver" |
|
]; |
|
|
|
/** |
|
* This interface allows applications to monitor changes the state |
|
* of the registry. |
|
* |
|
**/ |
|
IceGrid.RegistryObserver = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.RegistryObserverPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.RegistryObserver, IceGrid.RegistryObserverPrx, iceC_IceGrid_RegistryObserver_ids, 1, |
|
{ |
|
"registryInit": [, , , , , [["IceGrid.RegistryInfoSeqHelper"]], , , , ], |
|
"registryUp": [, , , , , [[IceGrid.RegistryInfo]], , , , ], |
|
"registryDown": [, , , , , [[7]], , , , ] |
|
}); |
|
|
|
Slice.defineSequence(IceGrid, "NodeDynamicInfoSeqHelper", "IceGrid.NodeDynamicInfo", false); |
|
|
|
const iceC_IceGrid_NodeObserver_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::NodeObserver" |
|
]; |
|
|
|
/** |
|
* The node observer interface. Observers should implement this |
|
* interface to receive information about the state of the IceGrid |
|
* nodes. |
|
* |
|
**/ |
|
IceGrid.NodeObserver = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.NodeObserverPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.NodeObserver, IceGrid.NodeObserverPrx, iceC_IceGrid_NodeObserver_ids, 1, |
|
{ |
|
"nodeInit": [, , , , , [["IceGrid.NodeDynamicInfoSeqHelper"]], , , , ], |
|
"nodeUp": [, , , , , [[IceGrid.NodeDynamicInfo]], , , , ], |
|
"nodeDown": [, , , , , [[7]], , , , ], |
|
"updateServer": [, , , , , [[7], [IceGrid.ServerDynamicInfo]], , , , ], |
|
"updateAdapter": [, , , , , [[7], [IceGrid.AdapterDynamicInfo]], , , , ] |
|
}); |
|
|
|
const iceC_IceGrid_ApplicationObserver_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::ApplicationObserver" |
|
]; |
|
|
|
/** |
|
* The database observer interface. Observers should implement this |
|
* interface to receive information about the state of the IceGrid |
|
* registry database. |
|
* |
|
**/ |
|
IceGrid.ApplicationObserver = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.ApplicationObserverPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.ApplicationObserver, IceGrid.ApplicationObserverPrx, iceC_IceGrid_ApplicationObserver_ids, 1, |
|
{ |
|
"applicationInit": [, , , , , [[3], ["IceGrid.ApplicationInfoSeqHelper"]], , , true, ], |
|
"applicationAdded": [, , , , , [[3], [IceGrid.ApplicationInfo]], , , true, ], |
|
"applicationRemoved": [, , , , , [[3], [7]], , , , ], |
|
"applicationUpdated": [, , , , , [[3], [IceGrid.ApplicationUpdateInfo]], , , true, ] |
|
}); |
|
|
|
const iceC_IceGrid_AdapterObserver_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::AdapterObserver" |
|
]; |
|
|
|
/** |
|
* This interface allows applications to monitor the state of object |
|
* adapters that are registered with IceGrid. |
|
* |
|
**/ |
|
IceGrid.AdapterObserver = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.AdapterObserverPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.AdapterObserver, IceGrid.AdapterObserverPrx, iceC_IceGrid_AdapterObserver_ids, 1, |
|
{ |
|
"adapterInit": [, , , , , [["IceGrid.AdapterInfoSeqHelper"]], , , , ], |
|
"adapterAdded": [, , , , , [[IceGrid.AdapterInfo]], , , , ], |
|
"adapterUpdated": [, , , , , [[IceGrid.AdapterInfo]], , , , ], |
|
"adapterRemoved": [, , , , , [[7]], , , , ] |
|
}); |
|
|
|
const iceC_IceGrid_ObjectObserver_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::ObjectObserver" |
|
]; |
|
|
|
/** |
|
* This interface allows applications to monitor IceGrid well-known objects. |
|
* |
|
**/ |
|
IceGrid.ObjectObserver = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.ObjectObserverPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.ObjectObserver, IceGrid.ObjectObserverPrx, iceC_IceGrid_ObjectObserver_ids, 1, |
|
{ |
|
"objectInit": [, , , , , [["IceGrid.ObjectInfoSeqHelper"]], , , , ], |
|
"objectAdded": [, , , , , [[IceGrid.ObjectInfo]], , , , ], |
|
"objectUpdated": [, , , , , [[IceGrid.ObjectInfo]], , , , ], |
|
"objectRemoved": [, , , , , [[Ice.Identity]], , , , ] |
|
}); |
|
|
|
const iceC_IceGrid_AdminSession_ids = [ |
|
"::Glacier2::Session", |
|
"::Ice::Object", |
|
"::IceGrid::AdminSession" |
|
]; |
|
|
|
/** |
|
* Used by administrative clients to view, |
|
* update, and receive observer updates from the IceGrid |
|
* registry. Admin sessions are created either via the {@link Registry} |
|
* object or via the registry admin <code>SessionManager</code> object. |
|
* |
|
* @see Registry |
|
* |
|
**/ |
|
IceGrid.AdminSession = class extends Ice.Object |
|
{ |
|
static get _iceImplements() |
|
{ |
|
return [ |
|
Glacier2.Session |
|
]; |
|
} |
|
}; |
|
|
|
IceGrid.AdminSessionPrx = class extends Ice.ObjectPrx |
|
{ |
|
static get _implements() |
|
{ |
|
return [ |
|
Glacier2.SessionPrx]; |
|
} |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.AdminSession, IceGrid.AdminSessionPrx, iceC_IceGrid_AdminSession_ids, 2, |
|
{ |
|
"keepAlive": [, 2, 2, , , , , , , ], |
|
"getAdmin": [, 2, 1, , ["IceGrid.AdminPrx"], , , , , ], |
|
"getAdminCallbackTemplate": [, 2, 2, , [9], , , , , ], |
|
"setObservers": [, 2, 2, , , [["IceGrid.RegistryObserverPrx"], ["IceGrid.NodeObserverPrx"], ["IceGrid.ApplicationObserverPrx"], ["IceGrid.AdapterObserverPrx"], ["IceGrid.ObjectObserverPrx"]], , |
|
[ |
|
IceGrid.ObserverAlreadyRegisteredException |
|
], , ], |
|
"setObserversByIdentity": [, 2, 2, , , [[Ice.Identity], [Ice.Identity], [Ice.Identity], [Ice.Identity], [Ice.Identity]], , |
|
[ |
|
IceGrid.ObserverAlreadyRegisteredException |
|
], , ], |
|
"startUpdate": [, , , , [3], , , |
|
[ |
|
IceGrid.AccessDeniedException |
|
], , ], |
|
"finishUpdate": [, , , , , , , |
|
[ |
|
IceGrid.AccessDeniedException |
|
], , ], |
|
"getReplicaName": [, 2, 2, , [7], , , , , ], |
|
"openServerLog": [, , , , ["IceGrid.FileIteratorPrx"], [[7], [7], [3]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.FileNotAvailableException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"openServerStdErr": [, , , , ["IceGrid.FileIteratorPrx"], [[7], [3]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.FileNotAvailableException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"openServerStdOut": [, , , , ["IceGrid.FileIteratorPrx"], [[7], [3]], , |
|
[ |
|
IceGrid.DeploymentException, |
|
IceGrid.FileNotAvailableException, |
|
IceGrid.NodeUnreachableException, |
|
IceGrid.ServerNotExistException |
|
], , ], |
|
"openNodeStdErr": [, , , , ["IceGrid.FileIteratorPrx"], [[7], [3]], , |
|
[ |
|
IceGrid.FileNotAvailableException, |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"openNodeStdOut": [, , , , ["IceGrid.FileIteratorPrx"], [[7], [3]], , |
|
[ |
|
IceGrid.FileNotAvailableException, |
|
IceGrid.NodeNotExistException, |
|
IceGrid.NodeUnreachableException |
|
], , ], |
|
"openRegistryStdErr": [, , , , ["IceGrid.FileIteratorPrx"], [[7], [3]], , |
|
[ |
|
IceGrid.FileNotAvailableException, |
|
IceGrid.RegistryNotExistException, |
|
IceGrid.RegistryUnreachableException |
|
], , ], |
|
"openRegistryStdOut": [, , , , ["IceGrid.FileIteratorPrx"], [[7], [3]], , |
|
[ |
|
IceGrid.FileNotAvailableException, |
|
IceGrid.RegistryNotExistException, |
|
IceGrid.RegistryUnreachableException |
|
], , ] |
|
}); |
|
|
|
}()); |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
// |
|
// Ice version 3.7.3 |
|
// |
|
// <auto-generated> |
|
// |
|
// Generated from file `FileParser.ice' |
|
// |
|
// Warning: do not edit this file. |
|
// |
|
// </auto-generated> |
|
// |
|
|
|
/* eslint-disable */ |
|
/* jshint ignore: start */ |
|
|
|
|
|
/** |
|
* This exception is raised if an error occurs during parsing. |
|
* |
|
**/ |
|
IceGrid.ParseException = class extends Ice.UserException |
|
{ |
|
constructor(reason = "", _cause = "") |
|
{ |
|
super(_cause); |
|
this.reason = reason; |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::ParseException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.ParseException; |
|
} |
|
|
|
_writeMemberImpl(ostr) |
|
{ |
|
ostr.writeString(this.reason); |
|
} |
|
|
|
_readMemberImpl(istr) |
|
{ |
|
this.reason = istr.readString(); |
|
} |
|
}; |
|
|
|
const iceC_IceGrid_FileParser_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::FileParser" |
|
]; |
|
|
|
/** |
|
* <code>icegridadmin</code> provides a {@link FileParser} |
|
* object to transform XML files into {@link ApplicationDescriptor} |
|
* objects. |
|
* |
|
**/ |
|
IceGrid.FileParser = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.FileParserPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.FileParser, IceGrid.FileParserPrx, iceC_IceGrid_FileParser_ids, 1, |
|
{ |
|
"parse": [, 2, 2, , [IceGrid.ApplicationDescriptor], [[7], ["IceGrid.AdminPrx"]], , |
|
[ |
|
IceGrid.ParseException |
|
], , true] |
|
}); |
|
|
|
}()); |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
// |
|
// Ice version 3.7.3 |
|
// |
|
// <auto-generated> |
|
// |
|
// Generated from file `Session.ice' |
|
// |
|
// Warning: do not edit this file. |
|
// |
|
// </auto-generated> |
|
// |
|
|
|
/* eslint-disable */ |
|
/* jshint ignore: start */ |
|
|
|
|
|
const iceC_IceGrid_Session_ids = [ |
|
"::Glacier2::Session", |
|
"::Ice::Object", |
|
"::IceGrid::Session" |
|
]; |
|
|
|
/** |
|
* A session object is used by IceGrid clients to allocate and |
|
* release objects. Client sessions are created either via the |
|
* {@link Registry} object or via the registry client <code>SessionManager</code> |
|
* object. |
|
* |
|
* @see Registry |
|
* |
|
**/ |
|
IceGrid.Session = class extends Ice.Object |
|
{ |
|
static get _iceImplements() |
|
{ |
|
return [ |
|
Glacier2.Session |
|
]; |
|
} |
|
}; |
|
|
|
IceGrid.SessionPrx = class extends Ice.ObjectPrx |
|
{ |
|
static get _implements() |
|
{ |
|
return [ |
|
Glacier2.SessionPrx]; |
|
} |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.Session, IceGrid.SessionPrx, iceC_IceGrid_Session_ids, 2, |
|
{ |
|
"keepAlive": [, 2, 2, , , , , , , ], |
|
"allocateObjectById": [, , , , [9], [[Ice.Identity]], , |
|
[ |
|
IceGrid.AllocationException, |
|
IceGrid.ObjectNotRegisteredException |
|
], , ], |
|
"allocateObjectByType": [, , , , [9], [[7]], , |
|
[ |
|
IceGrid.AllocationException |
|
], , ], |
|
"releaseObject": [, , , , , [[Ice.Identity]], , |
|
[ |
|
IceGrid.AllocationException, |
|
IceGrid.ObjectNotRegisteredException |
|
], , ], |
|
"setAllocationTimeout": [, 2, 2, , , [[3]], , , , ] |
|
}); |
|
|
|
}()); |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
// |
|
// Ice version 3.7.3 |
|
// |
|
// <auto-generated> |
|
// |
|
// Generated from file `Registry.ice' |
|
// |
|
// Warning: do not edit this file. |
|
// |
|
// </auto-generated> |
|
// |
|
|
|
/* eslint-disable */ |
|
/* jshint ignore: start */ |
|
|
|
|
|
/** |
|
* Determines which load sampling interval to use. |
|
* |
|
**/ |
|
IceGrid.LoadSample = Slice.defineEnum([ |
|
['LoadSample1', 0], ['LoadSample5', 1], ['LoadSample15', 2]]); |
|
|
|
const iceC_IceGrid_Query_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::Query" |
|
]; |
|
|
|
/** |
|
* The IceGrid query interface. This interface is accessible to |
|
* Ice clients who wish to look up well-known objects. |
|
* |
|
**/ |
|
IceGrid.Query = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.QueryPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.Query, IceGrid.QueryPrx, iceC_IceGrid_Query_ids, 1, |
|
{ |
|
"findObjectById": [, 2, 1, , [9], [[Ice.Identity]], , , , ], |
|
"findObjectByType": [, 2, 1, , [9], [[7]], , , , ], |
|
"findObjectByTypeOnLeastLoadedNode": [, 2, 1, , [9], [[7], [IceGrid.LoadSample._helper]], , , , ], |
|
"findAllObjectsByType": [, 2, 1, , ["Ice.ObjectProxySeqHelper"], [[7]], , , , ], |
|
"findAllReplicas": [, 2, 2, , ["Ice.ObjectProxySeqHelper"], [[9]], , , , ] |
|
}); |
|
|
|
const iceC_IceGrid_Registry_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::Registry" |
|
]; |
|
|
|
/** |
|
* The IceGrid registry allows clients create sessions |
|
* directly with the registry. |
|
* |
|
* @see Session |
|
* @see AdminSession |
|
* |
|
**/ |
|
IceGrid.Registry = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.RegistryPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.Registry, IceGrid.RegistryPrx, iceC_IceGrid_Registry_ids, 1, |
|
{ |
|
"createSession": [, , , , ["IceGrid.SessionPrx"], [[7], [7]], , |
|
[ |
|
IceGrid.PermissionDeniedException |
|
], , ], |
|
"createAdminSession": [, , , , ["IceGrid.AdminSessionPrx"], [[7], [7]], , |
|
[ |
|
IceGrid.PermissionDeniedException |
|
], , ], |
|
"createSessionFromSecureConnection": [, , , , ["IceGrid.SessionPrx"], , , |
|
[ |
|
IceGrid.PermissionDeniedException |
|
], , ], |
|
"createAdminSessionFromSecureConnection": [, , , , ["IceGrid.AdminSessionPrx"], , , |
|
[ |
|
IceGrid.PermissionDeniedException |
|
], , ], |
|
"getSessionTimeout": [, 2, 1, , [3], , , , , ], |
|
"getACMTimeout": [, 2, 1, , [3], , , , , ] |
|
}); |
|
|
|
const iceC_IceGrid_Locator_ids = [ |
|
"::Ice::Locator", |
|
"::Ice::Object", |
|
"::IceGrid::Locator" |
|
]; |
|
|
|
/** |
|
* The IceGrid locator interface provides access to the {@link Query} |
|
* and {@link Registry} object of the IceGrid registry. |
|
* |
|
* @see Query |
|
* @see Registry |
|
* |
|
**/ |
|
IceGrid.Locator = class extends Ice.Object |
|
{ |
|
static get _iceImplements() |
|
{ |
|
return [ |
|
Ice.Locator |
|
]; |
|
} |
|
}; |
|
|
|
IceGrid.LocatorPrx = class extends Ice.ObjectPrx |
|
{ |
|
static get _implements() |
|
{ |
|
return [ |
|
Ice.LocatorPrx]; |
|
} |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.Locator, IceGrid.LocatorPrx, iceC_IceGrid_Locator_ids, 2, |
|
{ |
|
"getLocalRegistry": [, 2, 2, , ["IceGrid.RegistryPrx"], , , , , ], |
|
"getLocalQuery": [, 2, 2, , ["IceGrid.QueryPrx"], , , , , ] |
|
}); |
|
|
|
}()); |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
// |
|
// Ice version 3.7.3 |
|
// |
|
// <auto-generated> |
|
// |
|
// Generated from file `UserAccountMapper.ice' |
|
// |
|
// Warning: do not edit this file. |
|
// |
|
// </auto-generated> |
|
// |
|
|
|
/* eslint-disable */ |
|
/* jshint ignore: start */ |
|
|
|
|
|
/** |
|
* This exception is raised if a user account for a given session |
|
* identifier can't be found. |
|
* |
|
**/ |
|
IceGrid.UserAccountNotFoundException = class extends Ice.UserException |
|
{ |
|
constructor(_cause = "") |
|
{ |
|
super(_cause); |
|
} |
|
|
|
static get _parent() |
|
{ |
|
return Ice.UserException; |
|
} |
|
|
|
static get _id() |
|
{ |
|
return "::IceGrid::UserAccountNotFoundException"; |
|
} |
|
|
|
_mostDerivedType() |
|
{ |
|
return IceGrid.UserAccountNotFoundException; |
|
} |
|
}; |
|
|
|
const iceC_IceGrid_UserAccountMapper_ids = [ |
|
"::Ice::Object", |
|
"::IceGrid::UserAccountMapper" |
|
]; |
|
|
|
/** |
|
* A user account mapper object is used by IceGrid nodes to map |
|
* session identifiers to user accounts. |
|
* |
|
**/ |
|
IceGrid.UserAccountMapper = class extends Ice.Object |
|
{ |
|
}; |
|
|
|
IceGrid.UserAccountMapperPrx = class extends Ice.ObjectPrx |
|
{ |
|
}; |
|
|
|
Slice.defineOperations(IceGrid.UserAccountMapper, IceGrid.UserAccountMapperPrx, iceC_IceGrid_UserAccountMapper_ids, 1, |
|
{ |
|
"getUserAccount": [, , , , [7], [[7]], , |
|
[ |
|
IceGrid.UserAccountNotFoundException |
|
], , ] |
|
}); |
|
|
|
}()); |
|
|
|
(function() |
|
{ |
|
// |
|
// Copyright (c) ZeroC, Inc. All rights reserved. |
|
// |
|
|
|
|
|
|
|
}()); |
|
|
|
root.IceGrid = IceGrid; |
|
root.ice = ice; |
|
}()); |
|
|
|
|