Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Post History
I'm working on an integration with a proprietary (black box) system. There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and it's being sent in...
#6: Post edited
by
Welz
·
2022-04-06T03:30:26Z (about 2 years ago)
- I'm working on an integration with a proprietary (black box) system.
There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format- ```txt
ID[I]=123, USER[S]=8080, PASS[S]=0000,- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
Types (assumed)- - `I` = Integer
- - `S` = String
Assuming this, the JSON equivalent of the above example would be- ```json
- {
- "ID": 123,
"USER": "8080",- "PASS": "0000"
- }
- ```
___- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
**Edit:** it's worth noting that it's very possible that this is completely a proprietary data format unique to the system I'm working with. I figured that if it's following any sort of standard I could read up on it more.
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and it's being sent in following data format
- ```txt
- ID[I]=123, USER[S]=JOHN DOE, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed - but very confident)
- - `I` = Integer
- - `S` = String
- Assuming this, the JSON equivalent of the above example would be
- ```json
- {
- "ID": 123,
- "USER": "JOHN DOE",
- "PASS": "0000"
- }
- ```
- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
- It's worth noting that it's very possible that this is completely a proprietary data format unique to the system I'm working with. I figured that if it's following any sort of standard I could read up on it more. I also changed the actual keys/values so as not to give out anything secret, the data format is the same.
#5: Post edited
by
Welz
·
2022-04-05T03:54:31Z (about 2 years ago)
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
- Assuming this, the JSON equivalent of the above example would be
- ```json
- {
- "ID": 123,
- "USER": "8080",
- "PASS": "0000"
- }
- ```
- ___
- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
- Assuming this, the JSON equivalent of the above example would be
- ```json
- {
- "ID": 123,
- "USER": "8080",
- "PASS": "0000"
- }
- ```
- ___
- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
- **Edit:** it's worth noting that it's very possible that this is completely a proprietary data format unique to the system I'm working with. I figured that if it's following any sort of standard I could read up on it more.
#4: Post edited
by
Welz
·
2022-04-04T16:05:16Z (about 2 years ago)
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).The JSON equivalent of the above example would be- ```json
- {
- "ID": 123,
- "USER": "8080",
- "PASS": "0000"
- }
```
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
- Assuming this, the JSON equivalent of the above example would be
- ```json
- {
- "ID": 123,
- "USER": "8080",
- "PASS": "0000"
- }
- ```
- ___
- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
#3: Post edited
by
Welz
·
2022-04-04T16:04:45Z (about 2 years ago)
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
- The JSON equivalent of the above example would be
- ```json
- {
- "ID": 123,
- "USER": "8080",
- "PASS": "0000"
- }
- ```
#2: Post edited
by
Welz
·
2022-04-04T16:03:43Z (about 2 years ago)
I'm working on an integration with a proprietary (black box) system. I apologize in advance for needing to be vague about what I found.- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
- I'm working on an integration with a proprietary (black box) system.
- There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format
- ```txt
- ID[I]=123, USER[S]=8080, PASS[S]=0000,
- ```
- My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value`
- Types (assumed)
- - `I` = Integer
- - `S` = String
- My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).
#1: Initial revision
by
Welz
·
2022-04-04T16:02:37Z (about 2 years ago)
Is there a name for a data format like `key[type]=value`?
I'm working on an integration with a proprietary (black box) system. I apologize in advance for needing to be vague about what I found. There is some TCP communication that occurs between two microservices. I've managed to sniff the traffic and come up with the following data format ```txt ID[I]=123, USER[S]=8080, PASS[S]=0000, ``` My understanding is that each line is an object, with each child separated by a comma and structured like `key[type]=value` Types (assumed) - `I` = Integer - `S` = String My question is if this is similar to any known standard? I'd like to look into this more (rather than making more assumptions).