Class: Quark::Mdk::SessionImpl

Inherits:
DatawireQuarkCore::QuarkObject show all
Extended by:
DatawireQuarkCore::Static
Defined in:
lib/mdk.rb

Constant Summary

Constants included from DatawireQuarkCore::Static

DatawireQuarkCore::Static::Unassigned

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from DatawireQuarkCore::Static

_lazy_statics, static, unlazy_statics

Methods inherited from DatawireQuarkCore::QuarkObject

#to_s

Constructor Details

#initialize(mdk, encodedContext, localEnvironment) ⇒ SessionImpl

Returns a new instance of SessionImpl.



1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
 
# File 'lib/mdk.rb', line 1079

def initialize(mdk, encodedContext, localEnvironment)
    
    self.__init_fields__
    @_experimental = ((mdk)._runtime.getEnvVarsService().var("MDK_EXPERIMENTAL").orElseGet("")) != ("")
    @_mdk = mdk
    encodedContext = ::DatawireQuarkCore.cast(encodedContext) { ::String }
    if (((encodedContext) == (nil)) || ((encodedContext) == ("")))
        @_context = ::Quark.mdk_protocol.SharedContext.new()
        (@_context).environment = localEnvironment
    else
        ctx = ::Quark.mdk_protocol.SharedContext.decode(encodedContext)
        @_context = ctx.start_span()
    end
    self._start_interaction()

    nil
end

Instance Attribute Details

#_context ⇒ Object

Returns the value of attribute _context.



1062
1063
1064
 
# File 'lib/mdk.rb', line 1062

def _context
  @_context
end

#_experimental ⇒ Object

Returns the value of attribute _experimental.



1062
1063
1064
 
# File 'lib/mdk.rb', line 1062

def _experimental
  @_experimental
end

#_interactionReports ⇒ Object

Returns the value of attribute _interactionReports.



1062
1063
1064
 
# File 'lib/mdk.rb', line 1062

def _interactionReports
  @_interactionReports
end

#_mdk ⇒ Object

Returns the value of attribute _mdk.



1062
1063
1064
 
# File 'lib/mdk.rb', line 1062

def _mdk
  @_mdk
end

#_resolved ⇒ Object

Returns the value of attribute _resolved.



1062
1063
1064
 
# File 'lib/mdk.rb', line 1062

def _resolved
  @_resolved
end

Class Method Details

._level(level) ⇒ Object 



1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
 
# File 'lib/mdk.rb', line 1188

def self._level(level)
    
    if ((::Quark.mdk.SessionImpl._levels).key?(level))
        return (::Quark.mdk.SessionImpl._levels)[level]
    else
        return 0
    end

    nil
end

Instance Method Details

#__init_fields__ ⇒ Object 



1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
 
# File 'lib/mdk.rb', line 1479

def __init_fields__()
    
    self._mdk = nil
    self._resolved = ::DatawireQuarkCore::List.new([])
    self._interactionReports = ::DatawireQuarkCore::List.new([])
    self._context = nil
    self._experimental = false

    nil
end

#_current_interaction ⇒ Object 



1318
1319
1320
1321
1322
1323
 
# File 'lib/mdk.rb', line 1318

def _current_interaction()
    
    return (@_resolved)[((@_resolved).size) - (1)]

    nil
end

#_enabled(level) ⇒ Object 



1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
 
# File 'lib/mdk.rb', line 1199

def _enabled(level)
    
    ilevel = ::Quark.mdk.SessionImpl._level("INFO")
    if (self.hasProperty("trace"))
        ilevel = ::Quark.mdk.SessionImpl._level(::DatawireQuarkCore.cast(self.getProperty("trace")) { ::String })
    end
    return (::Quark.mdk.SessionImpl._level(level)) <= (ilevel)

    nil
end

#_getClass ⇒ Object 



1417
1418
1419
1420
1421
1422
 
# File 'lib/mdk.rb', line 1417

def _getClass()
    
    return "mdk.SessionImpl"

    nil
end

#_getField(name) ⇒ Object 



1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
 
# File 'lib/mdk.rb', line 1424

def _getField(name)
    
    if ((name) == ("_levels"))
        return ::Quark.mdk.SessionImpl._levels
    end
    if ((name) == ("_inLogging"))
        return ::Quark.mdk.SessionImpl._inLogging
    end
    if ((name) == ("_mdk"))
        return (self)._mdk
    end
    if ((name) == ("_resolved"))
        return (self)._resolved
    end
    if ((name) == ("_interactionReports"))
        return (self)._interactionReports
    end
    if ((name) == ("_context"))
        return (self)._context
    end
    if ((name) == ("_experimental"))
        return (self)._experimental
    end
    return nil

    nil
end

#_log(level, category, text) ⇒ Object 



1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
 
# File 'lib/mdk.rb', line 1210

def _log(level, category, text)
    
    if (::Quark.mdk.SessionImpl._inLogging.getValue())
        return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk.LoggedMessageId }
    end
    ::Quark.mdk.SessionImpl._inLogging.setValue(true)
    evt = ::Quark.mdk_tracing.createLogEvent(@_context, (@_mdk).procUUID, level, category, text)
    if ((((@_mdk)._tracer) != (nil)) && (self._enabled(level)))
        (@_mdk)._tracer.log(evt)
    end
    ::Quark.mdk.SessionImpl._inLogging.setValue(false)
    return ::Quark.mdk.LoggedMessageId.new((@_context).traceId, (((evt).context).clock).clocks, ((@_context).environment).name, ((@_context).environment).fallbackName)

    nil
end

#_resolve(service, version) ⇒ Object 



1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
 
# File 'lib/mdk.rb', line 1261

def _resolve(service, version)
    
    if (@_experimental)
        routes = ::DatawireQuarkCore.cast(self.getProperty("routes")) { ::Hash }
        if (((routes) != (nil)) && ((routes).key?(service)))
            targets = (routes)[service]
            idx = 0
            while ((idx) < ((targets).size)) do
                target = (targets)[idx]
                if (::Quark.mdk_util.versionMatch((target)["version"], version))
                    service = (target)["target"]
                    version = (target)["targetVersion"]
                    break
                end
                idx = (idx) + (1)
            end
        end
    end
    return (@_mdk)._disco.resolve(service, version, self.getEnvironment()).andThen(::Quark.quark._BoundMethod.new(self, "_resolvedCallback", ::DatawireQuarkCore::List.new([])))

    nil
end

#_resolvedCallback(result) ⇒ Object 



1310
1311
1312
1313
1314
1315
1316
 
# File 'lib/mdk.rb', line 1310

def _resolvedCallback(result)
    
    (self._current_interaction()) << (result)
    return result

    nil
end

#_setField(name, value) ⇒ Object 



1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
 
# File 'lib/mdk.rb', line 1452

def _setField(name, value)
    
    if ((name) == ("_levels"))
        ::Quark.mdk.SessionImpl._levels = ::DatawireQuarkCore.cast(value) { ::Hash }
    end
    if ((name) == ("_inLogging"))
        ::Quark.mdk.SessionImpl._inLogging = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::TLS }
    end
    if ((name) == ("_mdk"))
        (self)._mdk = ::DatawireQuarkCore.cast(value) { ::Quark.mdk.MDKImpl }
    end
    if ((name) == ("_resolved"))
        (self)._resolved = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
    end
    if ((name) == ("_interactionReports"))
        (self)._interactionReports = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
    end
    if ((name) == ("_context"))
        (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.SharedContext }
    end
    if ((name) == ("_experimental"))
        (self)._experimental = ::DatawireQuarkCore.cast(value) { ::Object }
    end

    nil
end

#_start_interaction ⇒ Object 



1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
 
# File 'lib/mdk.rb', line 1334

def _start_interaction()
    
    interactionReport = ::Quark.mdk_metrics.InteractionEvent.new()
    (interactionReport).node = (@_mdk).procUUID
    (interactionReport).startTimestamp = ((1000.0) * ((@_mdk)._runtime.getTimeService().time())).round()
    (interactionReport).session = (@_context).traceId
    (interactionReport).environment = (@_context).environment
    (@_interactionReports) << (interactionReport)
    (@_resolved) << (::DatawireQuarkCore::List.new([]))
    return interactionReport

    nil
end

#critical(category, text) ⇒ Object 



1226
1227
1228
1229
1230
1231
 
# File 'lib/mdk.rb', line 1226

def critical(category, text)
    
    return self._log("CRITICAL", category, text)

    nil
end

#debug(category, text) ⇒ Object 



1254
1255
1256
1257
1258
1259
 
# File 'lib/mdk.rb', line 1254

def debug(category, text)
    
    return self._log("DEBUG", category, text)

    nil
end

#error(category, text) ⇒ Object 



1233
1234
1235
1236
1237
1238
 
# File 'lib/mdk.rb', line 1233

def error(category, text)
    
    return self._log("ERROR", category, text)

    nil
end

#externalize ⇒ Object 



1355
1356
1357
1358
1359
1360
1361
1362
 
# File 'lib/mdk.rb', line 1355

def externalize()
    
    result = @_context.encode()
    @_context.tick()
    return result

    nil
end

#fail_interaction(message) ⇒ Object 



1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
 
# File 'lib/mdk.rb', line 1364

def fail_interaction(message)
    
    suspects = self._current_interaction()
    (@_resolved)[((@_resolved).size) - (1)] = (::DatawireQuarkCore::List.new([]))
    involved = ::DatawireQuarkCore::List.new([])
    idx = 0
    while ((idx) < ((suspects).size)) do
        node = (suspects)[idx]
        idx = (idx) + (1)
        (involved) << (node.toString())
        node.failure()
        (@_interactionReports)[((@_interactionReports).size) - (1)].addNode(node, false)
    end
    text = "no dependent services involved"
    if (((involved).size) > (0))
        text = ("involved: ") + ((involved).join(", "))
    end
    self.error("interaction failure", ((text) + ("\n\n")) + (message))

    nil
end

#finish_interaction ⇒ Object 



1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
 
# File 'lib/mdk.rb', line 1386

def finish_interaction()
    
    nodes = self._current_interaction()
    (@_resolved).delete_at(((@_resolved).size) - (1))
    report = (@_interactionReports).delete_at(((@_interactionReports).size) - (1))
    (report).endTimestamp = ((1000.0) * ((@_mdk)._runtime.getTimeService().time())).round()
    lmid = self.info("MDK", "Finished interaction.")
    (report).endClock = (lmid).causalLevel
    idx = 0
    while ((idx) < ((nodes).size)) do
        node = (nodes)[idx]
        node.success()
        report.addNode(node, true)
        idx = (idx) + (1)
    end
    if (((@_mdk)._metrics) != (nil))
        (@_mdk)._metrics.sendInteraction(report)
    end

    nil
end

#getEnvironment ⇒ Object 



1100
1101
1102
1103
1104
1105
 
# File 'lib/mdk.rb', line 1100

def getEnvironment()
    
    return ((self)._context).environment

    nil
end

#getProperty(property) ⇒ Object 



1107
1108
1109
1110
1111
1112
 
# File 'lib/mdk.rb', line 1107

def getProperty(property)
    
    return ((@_context).properties)[property]

    nil
end

#getRemainingTime ⇒ Object 



1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
 
# File 'lib/mdk.rb', line 1149

def getRemainingTime()
    
    deadline = ::DatawireQuarkCore.cast(self.getProperty("timeout")) { ::Float }
    if ((deadline) == (nil))
        return ::DatawireQuarkCore.cast(nil) { ::Float }
    end
    return (deadline) - ((@_mdk)._runtime.getTimeService().time())

    nil
end

#hasProperty(property) ⇒ Object 



1121
1122
1123
1124
1125
1126
 
# File 'lib/mdk.rb', line 1121

def hasProperty(property)
    
    return ((@_context).properties).key?(property)

    nil
end

#info(category, text) ⇒ Object 



1247
1248
1249
1250
1251
1252
 
# File 'lib/mdk.rb', line 1247

def info(category, text)
    
    return self._log("INFO", category, text)

    nil
end

#inject ⇒ Object 



1348
1349
1350
1351
1352
1353
 
# File 'lib/mdk.rb', line 1348

def inject()
    
    return self.externalize()

    nil
end

#interact(cmd) ⇒ Object 



1408
1409
1410
1411
1412
1413
1414
1415
 
# File 'lib/mdk.rb', line 1408

def interact(cmd)
    
    self.start_interaction()
    (cmd).call(self)
    self.finish_interaction()

    nil
end

#resolve(service, version) ⇒ Object 



1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
 
# File 'lib/mdk.rb', line 1291

def resolve(service, version)
    
    timeout = @_mdk._timeout()
    session_timeout = self.getRemainingTime()
    if (((session_timeout) != (nil)) && ((session_timeout) < (timeout)))
        timeout = session_timeout
    end
    return self.resolve_until(service, version, timeout)

    nil
end

#resolve_async(service, version) ⇒ Object 



1284
1285
1286
1287
1288
1289
 
# File 'lib/mdk.rb', line 1284

def resolve_async(service, version)
    
    return ::Quark.mdk_util.toNativePromise(self._resolve(service, version))

    nil
end

#resolve_until(service, version, timeout) ⇒ Object 



1303
1304
1305
1306
1307
1308
 
# File 'lib/mdk.rb', line 1303

def resolve_until(service, version, timeout)
    
    return ::DatawireQuarkCore.cast(::Quark.mdk_util.WaitForPromise.wait(self._resolve(service, version), timeout, (((("service ") + (service)) + ("(")) + (version)) + (")"))) { ::Quark.mdk_discovery.Node }

    nil
end

#route(service, version, target, targetVersion) ⇒ Object 



1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
 
# File 'lib/mdk.rb', line 1160

def route(service, version, target, targetVersion)
    
    routes = nil
    if (!(self.hasProperty("routes")))
        routes = {}
        self.setProperty("routes", routes)
    else
        routes = ::DatawireQuarkCore.cast(self.getProperty("routes")) { ::Hash }
    end
    targets = nil
    if ((routes).key?(service))
        targets = (routes)[service]
    else
        targets = ::DatawireQuarkCore::List.new([])
        (routes)[service] = (targets)
    end
    (targets) << ({"version" => version, "target" => target, "targetVersion" => targetVersion})

    nil
end

#setDeadline(timeout) ⇒ Object 



1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
 
# File 'lib/mdk.rb', line 1135

def setDeadline(timeout)
    
    current = self.getRemainingTime()
    if ((current) == (nil))
        current = timeout
    end
    if ((timeout) > (current))
        timeout = current
    end
    self.setProperty("timeout", ((@_mdk)._runtime.getTimeService().time()) + (timeout))

    nil
end

#setProperty(property, value) ⇒ Object 



1114
1115
1116
1117
1118
1119
 
# File 'lib/mdk.rb', line 1114

def setProperty(property, value)
    
    ((@_context).properties)[property] = (value)

    nil
end

#setTimeout(timeout) ⇒ Object 



1128
1129
1130
1131
1132
1133
 
# File 'lib/mdk.rb', line 1128

def setTimeout(timeout)
    
    self.setDeadline(timeout)

    nil
end

#start_interaction ⇒ Object 



1325
1326
1327
1328
1329
1330
1331
1332
 
# File 'lib/mdk.rb', line 1325

def start_interaction()
    
    interactionReport = self._start_interaction()
    lmid = self.info("MDK", "Starting interaction.")
    (interactionReport).startClock = (lmid).causalLevel

    nil
end

#trace(level) ⇒ Object 



1181
1182
1183
1184
1185
1186
 
# File 'lib/mdk.rb', line 1181

def trace(level)
    
    self.setProperty("trace", level)

    nil
end

#warn(category, text) ⇒ Object 



1240
1241
1242
1243
1244
1245
 
# File 'lib/mdk.rb', line 1240

def warn(category, text)
    
    return self._log("WARN", category, text)

    nil
end