async def initConnections(self, daliUpload):
if self.verbose:
print("initConnections...{}".format(daliUpload is not None))
if self.daliUpload is None:
# create a separate upload datalink
#self.daliUpload = simpleDali.SocketDataLink(self.host, self.port)
self.daliUpload = simpleDali.WebSocketDataLink(self.uri)
self.daliUpload.verbose = False
await self.authorize()
else:
await self.daliUpload.reconnect()
serverId = await self.daliUpload.id(self.programname, self.username,
self.processid, self.architecture)
if self.verbose:
print("Connect Upload: {}".format(serverId))
serverInfo = await self.daliUpload.info("STATUS")
print("Server Info: {}".format(serverInfo))
infoDict = self.daliUpload.parseInfoStatus(serverInfo)
for k, v in infoDict.items():
if isinstance(v, dict):
print(k)
for k, v in v.items():
print(" {} = {}".format(k, v))
else:
print(" {} = {}".format(k, v))
return self.daliUpload
def doTest(loop, token):
#dali = simpleDali.SocketDataLink(host, port)
dali = simpleDali.WebSocketDataLink(uri, verbose=True)
idTask = loop.create_task(
dali.id(programname, username, processid, architecture))
loop.run_until_complete(idTask)
serverId = idTask.result()
#serverId = await dali.id(programname, username, processid, architecture)
print("Resp: {}".format(serverId))
#serverInfo = yield from dali.info("STATUS")
#print("Info: {} ".format(serverInfo.message))
#serverInfo = yield from dali.info("STREAMS")
#print("Info: {} ".format(serverInfo.message))
# hptime = "1551313181711158"
# print("Position after: {} {:d}".format(hptime, int(hptime)))
# pafter = yield from dali.positionAfterHPTime(hptime)
# print("PacketId after: {} {}".format(pafter.type, pafter.value))
# nextPacket = yield from dali.read(pafter.value)
# print("next after: {} {} {}".format(nextPacket.type, nextPacket.dataStartTime, nextPacket.dataEndTime))
# print("hptime round trip: {} {}".format(hptime, simpleDali.datetimeToHPTime(simpleDali.hptimeToDatetime(int(hptime)))))
# nowTime = simpleDali.utcnowWithTz()
# print("hptime now: {} {}".format(hptime, simpleDali.datetimeToHPTime(simpleDali.hptimeToDatetime(int(hptime)))))
# test auth
if True:
authTask = loop.create_task(dali.auth(token))
loop.run_until_complete(authTask)
print("Auth Resp: {}".format(authTask.result()))
if True:
network = "XX"
station = "TEST"
location = "00"
channel = "HNZ"
starttime = simpleDali.utcnowWithTz()
numsamples = 100
sampleRate = 200
shortData = array("h") # shorts
for i in range(numsamples):
shortData.append(i)
msh = simpleMiniseed.MiniseedHeader(network, station, location,
channel, starttime, numsamples,
sampleRate)
msr = simpleMiniseed.MiniseedRecord(msh, shortData)
print("before writeMSeed")
sendTask = loop.create_task(dali.writeMSeed(msr))
loop.run_until_complete(sendTask)
print("writemseed resp {}".format(sendTask.result()))
closeTask = loop.create_task(dali.close())
loop.run_until_complete(closeTask)
async def initConnections(self, daliUpload):
if self.daliUpload is None:
# create a separate upload datalink
#self.daliUpload = simpleDali.SocketDataLink(self.host, self.port)
self.daliUpload = simpleDali.WebSocketDataLink(self.uri)
else:
self.daliUpload.reconnect()
#daliUpload.verbose = True
await self.authorize()
serverId = await self.daliUpload.id(self.programname, self.username,
self.processid, self.architecture)
if self.verbose:
print("Connect Upload: {}".format(serverId))
return self.daliUpload
async def doTest(loop):
#dali = simpleDali.SocketDataLink(host, port)
dali = simpleDali.WebSocketDataLink(uri)
dali.verbose = True
serverId = await dali.id(programname, username, processid, architecture)
print("Resp: {}".format(serverId))
serverInfo = await dali.info("STATUS")
print("Info: {} ".format(serverInfo.message))
#serverInfo = yield from dali.info("STREAMS")
#print("Info: {} ".format(serverInfo.message))
r = await dali.match(".*/MAXACC")
#print("match() Resonse {}".format(r))
begintime = datetime.utcnow() - timedelta(seconds=2)
r = await dali.positionAfter(begintime)
if r.type.startswith("ERROR"):
print(
"positionAfter() Resonse {}, ringserver might not know about these packets?"
.format(r))
else:
print("positionAfter() Resonse m={}".format(r.message))
r = await dali.stream()
while (keepGoing):
peakPacket = await dali.parseResponse()
if not peakPacket.type == "PACKET":
# might get an OK very first after stream
print("parseResponse not a PACKET {} ".format(peakPacket))
else:
peakInfo = {}
peakInfo = json.loads(peakPacket.data)
#print(peakInfo)
print("{} acceleration is {:7.5f} at {}".format(
peakInfo["station"], peakInfo["maxacc"], peakInfo["end_time"]))
peakInfo = {}
dali.close()
async def connection(loop):
try:
dali = simpleDali.WebSocketDataLink(uri)
await dali.parseResponse()
except Exception:
dali = simpleDali.SocketDataLink(host, port)
dali.verbose = True
serverId = await dali.id(programname, username, processid, architecture)
print("Resp: {}".format(serverId))
serverInfo = await dali.info("STATUS")
print("Info: {} ".format(serverInfo.message))
print("File directory?")
channelLoc = input()
if channelLoc == '0':
r = await dali.match("XX.XB08.00.HN./MSEED")
else:
r = await dali.match(channelLoc)
begintime = datetime.utcnow() - timedelta(seconds=2)
r = await dali.positionAfter(begintime)
if r.type.startswith("ERROR"):
print(
"positionAfter() Resonse {}, ringserver might not know about these packets?"
.format(r))
else:
print("positionAfter() Resonse m={}".format(r.message))
r = await dali.stream()
sys.stdout.flush()
while (keepGoing):
peakPacket = await dali.parseResponse()
if not peakPacket.type == "PACKET":
print("parseResponse not a PACKET {} ".format(peakPacket))
else:
peakInfo = {}
devationValues = []
squares = []
peakInfo = simpleMiniseed.unpackMiniseedRecord(
peakPacket.data).data
channelX = simpleMiniseed.unpackMiniseedHeader(
peakPacket.data).channel
timestamp = simpleMiniseed.unpackMiniseedRecord(
peakPacket.data).starttime()
average = sum(peakInfo) / len(peakInfo)
for x in range(len(peakInfo)):
squares.append(peakInfo[x]**2)
rms = math.sqrt(sum(squares) / len(peakInfo))
for x in range(len(peakInfo)):
devationValues.append((peakInfo[x] - average)**2)
devation = math.sqrt(sum(devationValues) / (len(peakInfo) - 1))
print('-========== Channel {} ==========-'.format(channelX))
print('standard dev = {}'.format(devation))
print('rms = {}'.format(rms))
print('max value = {}'.format(max(peakInfo)))
print('min value = {}'.format(min(peakInfo)))
print('average = {}'.format(average))
print('timestamp = {}'.format(timestamp))
peakInfo = {}
sys.stdout.flush()
dali.close()
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("-s",
dest="secretFile",
default="secret.key",
type=argparse.FileType('r'),
required=True,
help="secret key file, key on first line")
parser.add_argument(
"-p",
dest="pattern",
required=True,
help="regular expression match pattern for WRITE, like 'XX_.*/MTRIG'")
parser.add_argument("-u", dest="username", required=True, help="username")
parser.add_argument("--em",
dest="expireMinutes",
type=int,
default=10,
help="expire time from now in minutes")
parser.add_argument("--ed",
dest="expireDays",
type=int,
default=0,
help="expire time from now in days")
parser.add_argument(
"--verify",
dest="verify",
help=
"verify by sending an authorization requst to the datalink server at the given uri"
)
parser.add_argument("-o",
dest="outputFile",
type=argparse.FileType('w'),
help="output token file, encoded token on first line")
args = parser.parse_args(argv)
secretKey = args.secretFile.readline().strip()
token = simpleDali.encodeAuthToken(
args.username,
timedelta(days=args.expireDays, minutes=args.expireMinutes),
args.pattern, secretKey)
if args.outputFile is not None:
args.outputFile.write(token.decode('utf-8'))
args.outputFile.close()
else:
prettyPayload = json.dumps(simpleDali.decodeAuthToken(
token, secretKey),
indent=4,
sort_keys=True)
print("token payload as json: \n{}".format(prettyPayload))
print("token: \n\n{}\n".format(token.decode('utf-8')))
print("token expires in {}".format(
simpleDali.timeUntilExpireToken(token)))
if args.verify is not None:
loop = asyncio.get_event_loop()
#loop.set_debug(True)
programname = "createToken.py"
username = "******"
processid = 0
architecture = "python"
dali = simpleDali.WebSocketDataLink(args.verify, verbose=True)
idTask = loop.create_task(
dali.id(programname, username, processid, architecture))
loop.run_until_complete(idTask)
serverId = idTask.result()
print("Resp: {}".format(serverId))
authTask = loop.create_task(dali.auth(token))
loop.run_until_complete(authTask)
print("Auth Resp: {}".format(authTask.result()))
authTask = loop.create_task(dali.close())
loop.run_until_complete(authTask)
loop.close()