I would like help with setting up the right VAST parameter values for targeting MediaTailor Channel Assembly FAST Channel Programs.
Suppose, I've setup a Channel Assembly FAST Channel with 2 Programs (A and B). Program A has 2 mid-roll ad breaks. Program B has 1 mid-roll ad break. Channel is configured to play these 2 programs after each other in a loop. That is,
Program A -> Program B -> Program A -> Program B ... and so on in loop
I see that there are these 3 parameters ("splice_insert.avail_num", "splice_insert.splice_event_id", "splice_insert.unique_program_id") available when setting up an ad break in a Program.
Which of these should be used for distinguishing between Program A and B? And, which of these should be used for identifying a specific mid roll ad break (say, 1 or 2) within that program?
Also, could these be values be passed as parameters in VAST tag to Ad Server? For example, I want to use these parameters passed in the VAST tag to target the 2nd mid-roll ad break in Program A.
Thanks.
The values that are used for the splice_insert parameters in Channel Assembly are sent through to the server side ad insertion (SSAI) in the form of the session variables. For example, in Channel Assembly, splice_insert.avail_num becomes [scte.avail_num] in SSAI. Based on what you are trying to do, we would recommend one of the following:
Channel Assembly's splice_insert.splice_event_id > SSAI's [scte.event_id]
or
Channel Assembly's splice_insert.unique_program_id > SSAI's [scte.unique_program_id]
For more information on the SSAI session variables, please review https://docs.aws.amazon.com/mediatailor/latest/ug/variables-session.html
Related
I know that AAD application ID is unique in one directory (tenant). It is a guid and apparently should be unique in whole world but collisions may be. The question is: does Azure while generation AAD application ID validate whether it is unique across all others directories or not?
If you look at the official document for application property you would know application id is
The unique identifier for the application that is assigned to an
application by Azure AD. Not nullable. Read-only
How Azure Application Id Generated Uniquely:
Application Id (GUID) break down like this:
60 bits of timestamp,
48 bits of computer identifier,
14 bits of uniquifier, and
six bits are fixed
Total of 128 bits.
The goal of this algorithm is to use the combination of time and location (“space-time coordinates” for the relativity geeks out there) as the uniqueness key.
However, there’s a possibility that, for example, two GUIDs are generated in rapid succession from the same machine, so close to each other in time that the timestamp would be the same. That’s where the uniquifier comes in.
When time appears to have stood still (if two requests for a GUID are made in rapid succession) or gone backward (if the system clock is set to a new time earlier than what it was), the uniquifier is incremented so that GUIDs generated from the “second time it was five o’clock” don’t collide with those generated “the first time it was five o’clock”.
Once you see how it all works, it’s clear that you can’t just throw away part of the GUID since all the parts (well, except for the fixed parts) work together to establish the uniqueness. This is how all that works.
Note: Even sometimes network address also considered for GUID.
I am a new mainframer and I have been given access to/control of a test system to play around in and learn. We have been trying to get IMS set up on the system but when I try to log into IMS 14 I get the error
"INIT SELF FAILED WITH SENSE 08570002".
I have found that the error code means, "The SSCP-PLU session is inactive."
I am thinking that the issue is with the VTAM configuration but I am not sure what exactly needs to be fixed or where in z/OS to look for it.
I have asked around and dug through documentation with no luck so any help would be very much appreciated.
The message indicates an attempt was made to establish a connection from the SSCP (VTAM) and a Primary LU (an application) and the application was not available. This is done on behalf of an SLU (secondary logical unit) which is generally a terminal or printer.
This could the result of several situations but here are some common ones:
An attempt was made to log on to something like TSO, CICS, IMS, ... before the VTAM ACB was actually opened. You can attempt the request again later when the service is up
To determine if the PLU (application is available) use the the VTAM command D NET,ID=vtamappl where vtamappl is the application ID your are trying to connect to. This command is entered on the console directly or through a secondary means like SDSF.
There may be a LOGAPPL= statement coded on the LU definition that tells VTAM to attempt to initiate a session when starting the LU. In your case this would appear to be happening before the PLU (application) is up. The LU definition (or generic definition) is in the VTAMLST concatenation.
This manual describes the sense code in more detail.
Rfid Readers perform switches between antennas while using multiple antennas. Reader runs one antenna while others sleeping and switches one by one. It makes it fast so running one antenna at a time doesn't matter. According to my observations, the time for every switch is 1 second.
(After sometime I realised this 1 second is only for Motorola FX7500. Most other readers do it the right way, light fast like in miliseconds)
That is what I know so far.
Now, in my specific application I need this procedure to run faster, like 200ms instead of 1s.
Is this value changeable? If so, which message and parameter in LLRP can modify this value?
Actually the 1 second problem is with MotorolaFX7500 reader. By examining LLRP messages that Motorola's own library generates between FC7500, I discovered there are vendor specific parameters that can be used via custom extensions fields of LLRP. These params and settings can be found in Motorola Readers' software guide. This switch time is one of these vendor specific parameters, it's not a parameter of generic LLRP. A piece of code generating LLRP message including the custom extension with the proper format, solved my issue.
I am building a system comprising of 3 parts.
System A, system B, system C.
System A cannot directly talk to system C and needs to go through system B.
System B may contain many System Cs.
One more concern here is that it's possible for system B to create a copy/clone of itself and have it be included under itself (as a system C).
I would like to broadcast messages to all system Cs from system A. System B contains a list of all system Cs that it encapsulates.
I would like to add logic in System C wherein only messages originating from system A are considered as valid (and hence marked as safe for further processing).
As a first cut I was thinking of having a private key negotiated via the diffie-hellman algorithm. But realized that system B can create a copy of itself, have it be included as an instance of system C and obtain the private key.
Is there a better/standard way to do this such that the veracity of the source can be verified on the system C's side?
Sounds to me like a simple private/public key for every system A is all you need.
DH is not involved in this at all.
System A creates the keypair. System A uses its secret key to sign the hash of the message and sends it out through as many system Bs as needed.
System B cannot change the message nor derive the private key, so all they could do is not pass on the message or replay them (you'll need precautions for those if that's a problem).
System C needs to verify the signature of A on the message it either knows the public key of system A somehow, and verifies the signature.
To have more than one system A, it quickly becomes impractical to have (all) system Cs know all System A public keys, to solve that you create trust in a certificate authority (CA) that signs certificates for system As, and system C then trusts signed certificates by that CA. (it doesn't need to be online nor need to be able to talk to the CA to do that, the trust can easily be offline).
If you do go for an offline thing, take care that the keys (and/or certificates) might need to get updated, so foresee a mechanism for that.
As you see B is merely a transport in it all.
If there is nothing shared ahead of time, there is no way for a C to distinguish between messages that come from A and ones that come from a B who wants to impersonate an A. In your case, a shared secret key won't work, since that would allow B to forge messages. So you'll need something like a public key for A that B and C can use to verify messages, but which only A can use to create/sign messages.
I would like to know if it is possible to do a full statement (between a date range) through ISO 8583, I have seen ATMs which do full statements and was wondering what method they used. I know balance inquiry and mini statements are possible on a POS devise over 8583.
If it is possible does anyone have an information on the structure of the message, ideally for FLexcube.
we did something similar to that back in 1999 in one of the banks, where we would send the statement data in one of the generic private use fields, where it would allow the format ANS 999
but that means you are either to restrict the data to less than 999 characters, or to split the data on multiple messages. and have a multi legged transaction.
you would have the following flow
Customer request for statement on ATM
ATM sends NDC/D912 message to ATM Switch
ATM Switch look up account number after authenticating the card and forward the request to Core Banking Application
Core banking application would generate the statement and format it according to predesigned template and send the statement data into a generic field (say 72)
ATM Switch collects the data and formats it to NDC or D912 format where the statement data is tagged to statement printer (in NDC it is a field called q and the value should be ‘8’ - Print on statement printer only)
and on the field r place the preformatted data
however, it is not a good practice to do so, since we have faster means to generate a statement and send to email or internet banking. but this is the bank's preference anyways.
It depends upon implementation,
I had implemented NCR central switch, where I incorporate initial checking stuffs in the Central application itself rather than passing everything to Auth Host.
My implementation.
ATM Sends (NCD) the transaction requests based on State Machine setup in ATM to Central Application.
Central does basic checkings such as Validity of BIN (initial 6 digit of card no.) and also checks if the requested amount of cash is available in the ATM etc.
The the Central App sends the packet (ISO8583/BASE24) is sent to the Acquirer for further processing.
Acquires Sends it to CA and then it goes to Issuer for Approval.
Hope this helps.
The mini-statement is not part of ISO 8583 (or MVA). It is usually implemented as a proprietary extension. Hence you need to go to an ATM owned by your bank, or, is part of a consortium of banks that share an ATM infrastructure with your bank.
We implemented mini-statements in our ISO-8583 specification utilizing a $0.00 0200 (DE003 = 91xxxx) message and the statement data coming back from the host on DE125 on both Connex and Base24 and then modified our stateful loads to print the data at the ATM.
Though full statements fell out of use years ago so we removed it to just be mini-statements now utilizing the receipt printer vs. full page statements. There is a limited number of entries and not all host support it but it is used today on NCR & Diebold ATMs. I've personally participated in the testing in getting it to work on Base24 and Postilion.
The mini-statement data we do print is 40 characters per line and prints about 10 transactions I believe.