Changing settings on a dart websocket - websocket

I tried fiddling a little, but seeing that dart uses some wrapping classes internally, i'm not sure how i can set the settings of a socket. Specifically i try to create a low latency websocket-server, so i want to change the TCP_NODELAY flag (are there any other relevant flags/settings for low latency?) .
The code i have now is below. Seeing very high latencies when testing, i think its because of TCP_NODELAY. With a simple node.js socket-server i did mange to get low latencies.
import 'dart:io';
import 'dart:async';
import 'package:route/server.dart';
var port = 7654;
void main() {
HttpServer.bind(InternetAddress.ANY_IP_V4, port)
.then((HttpServer server) {
print('listening for connections on $port');
var router = new Router(server);
router.serve('/ws').transform(new WebSocketTransformer()).listen(blub);
router.serve('/').listen((req) {
req.response..write('foo ${new DateTime.now().millisecondsSinceEpoch}')..close();
});
},
onError: (error) => print("Error starting HTTP server: $error"));
}
void blub(WebSocket ws) {
print("## $ws");
ws.listen((obj) {
ws.add(obj);
print("## $obj ${new DateTime.now().millisecondsSinceEpoch}");
});
}

TCP_NODELAY is already enabled by the HttpServer.

Related

Open Telemetry for react and vanilla JS projects

Can someone help me understand if there is a way to configure open Telemetry on the client side for react and vanilla JS projects all I want to do is to console the traces of fetch call that are being made from the browser.
Most of the documentation I see is only for nodejs. Pls pinpoint a documentation if there are any?
The documentation gives a common guide for Javascript. What you do for you React would be same as what you do for Node.js or even simple JS scripts.
Just follow the documentation. Create and export a tracer:
import { ZoneContextManager } from '#opentelemetry/context-zone';
import { registerInstrumentations } from '#opentelemetry/instrumentation';
import { DocumentLoadInstrumentation } from '#opentelemetry/instrumentation-document-load';
import { FetchInstrumentation } from '#opentelemetry/instrumentation-fetch';
import { UserInteractionInstrumentation } from '#opentelemetry/instrumentation-user-interaction';
import { XMLHttpRequestInstrumentation } from '#opentelemetry/instrumentation-xml-http-request';
import { ConsoleSpanExporter, SimpleSpanProcessor } from '#opentelemetry/sdk-trace-base';
import { WebTracerProvider } from '#opentelemetry/sdk-trace-web';
const setupTracer = () => {
const provider = new WebTracerProvider();
provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
provider.register({
// Changing default contextManager to use ZoneContextManager - supports asynchronous operations - optional
contextManager: new ZoneContextManager(),
});
// Registering instrumentations
registerInstrumentations({
instrumentations: [
new DocumentLoadInstrumentation(),
new UserInteractionInstrumentation(),
new XMLHttpRequestInstrumentation(),
new FetchInstrumentation()
],
});
}
export default setupTracer;
Import the tracer like this in your app's entry point (usually index.js):
setupTracer();
ReactDOM.render(<App />, document.getElementById('root'));

How to integrate Heroku with Google Cloud SQL (native - GCP) in Nestjs/Typeorm?

I'm currently really frustating cause cannot deploy my app to Heroku and connect my db to Google Cloud SQL.
What am I already did?
I have been set up SSL to connect them
I have been set up Cloud SQL Auth Proxy (+ set up Cloud SQL CLient role in IAM Manager)
I have been did buildpacks via Heroku approaches
etc.
And overall failed.
This is my config database via Typeorm in Nestjs.
import { TypeOrmModuleOptions } from "#nestjs/typeorm"
const fs = require("fs");
require('dotenv').config()
export class OrmConfig {
// Config TypeOrm
getConfig() {
const ormConfig: TypeOrmModuleOptions = {
type: 'postgres',
url: 'postgres://myusername:mypassword#myhostincloudsql(publicip):5432/mydb',
// host: 'myhostincloudsql(public ip)',
// port: 5432,
// username: 'myusername',
// password: 'mypassword',
// database: 'mydb',
entities: ['dist/**/*.entity{.js,.ts}'],
synchronize: false,
migrationsRun: true,
logging: false,
logger: 'file',
migrations: [
'dist/database/migrations/**/*{.js, .ts}'
],
cli: {
migrationsDir: 'database/migrations'
},
ssl: true,
extra: {
ssl: {
ca: fs.readFileSync('./src/config/server-ca.pem'),
cert: fs.readFileSync('./src/config/client-cert.pem'),
key: fs.readFileSync('./src/config/client-key.pem'),
// rejectUnauthorized: false
}
}
}
return ormConfig
}
}
export default new OrmConfig().getConfig()
This is my app.module.ts
import { SendGridModule } from '#anchan828/nest-sendgrid';
import { MiddlewareConsumer, Module, NestModule } from '#nestjs/common';
import { ConfigModule } from '#nestjs/config';
import { TypeOrmModule } from '#nestjs/typeorm';
// import { BlogModule } from './blog/blog.module';
import OrmConfig from './config/ormConfig';
import { BusinessContactModule } from './contact/business/business.module';
import { InvestorNotificationController } from './contact/investor/investment-recommendation/investor-notification.controller';
import { InvestmentRecommendationModule } from './contact/investor/investment-recommendation/investor-notification.module';
import { InvestorContactModule } from './contact/investor/angel-investor/investor.module';
import { EmitenCampaignModule } from './emiten-campaign/emiten-campaign.module';
import { EmitenModule } from './emiten/emiten.module';
import { FlashMobileModule } from './flash-mobile/flash-mobile.module';
import { CoreModule } from './global/core.module';
import { Agent } from './middleware/agent';
import { AuthModule } from './middleware/auth.module';
import { TekenajaModule } from './tekenaja/tekenaja.module';
import { UserModule } from './user/user.module';
require('dotenv').config();
#Module({
imports: [
/**
* ================================
* Typeorm Config
* ================================
*/
SendGridModule.forRoot({
apikey: process.env.SENDGRID_API_KEY,
}),
TypeOrmModule.forRoot(OrmConfig), // This is I call it
ConfigModule.forRoot(),
AuthModule,
TekenajaModule,
FlashMobileModule,
CoreModule,
EmitenModule,
EmitenCampaignModule,
// InvestorContactModule,
// BusinessContactModule,
UserModule,
// BlogModule
InvestmentRecommendationModule
]
})
export class AppModule implements NestModule {
configure(consumer: MiddlewareConsumer) {
consumer
.apply(Agent)
.forRoutes('/');
}
}
NB: Anyway, I'm using public ip in Google Cloud SQL
I have tried connect it from Heroku Postgres, and works. And I try with Cloud SQL fields, getting error something like this
Now, what should I do in order to connected between them? I hope reply my issue guys. Many thanks.
In CloudSQL - your instance must have Public IP address ( section Connection ) and you need address IP in Authorised network from where you will try connect. Ofc you can setup 0.0.0.0 but don't do it. Better way is setup ssh connection.
Try running the Cloud SQL Proxy in addition to your app in the same dynamo.
For example:
web: trap '' SIGTERM; ./cloud_sql_proxy -credential_file sa.json -instances=INSTANCE_CONN_NAME=tcp:5432 & npm start & wait -n; kill -SIGTERM -$$; wait
Note, you'll need to ensure the Cloud SQL Proxy binary and a credential file is included with your app. And you won't want to check those into source control.
See https://help.heroku.com/CTFS2TJK/how-do-i-run-multiple-processes-on-a-dyno.
I have solved my issue. As mentioned #Sebastian Pietrzak, I should implemented 0.0.0.0/0 in Authorized Network in the Connection Menu. And for the additional you have to set the SSL appoach.
Many thanks everyones

Get Balance and all custom token list of Solana tokens in Wallet

I'm actually stuck at the first step on connecting to phantom wallet. I'm trying to perform the following step.
Connect to Phantom wallet
Get a Public key
Get Balance of all tokens
Perform Buy/Sell
I'm able to connect to a phantom wallet with the below code. I'm not sure if the next step in the process is to get a public key so that I can find the balance of all tokens as part of the account.
const balance = connection.getBalance(publicKey);
The above method is what I found from the documentation, but I'm not sure how can I get the publicKey of the end user who connected their wallet to the webiste.
const connection = new solanaWeb3.Connection(solanaWeb3.clusterApiUrl("mainnet-beta")) console.log(connection);
assume you have react app for integrating with solana wallets, first of all install these packages:
yarn add #solana/wallet-adapter-base \
#solana/wallet-adapter-react \
#solana/wallet-adapter-react-ui \
#solana/wallet-adapter-wallets \
#solana/web3.js \
react
you can use next, vue, angular, svelte and material ui as well
next we have this setup:
import React, { FC, useMemo } from 'react';
import { ConnectionProvider, WalletProvider } from '#solana/wallet-adapter-react';
import { WalletAdapterNetwork } from '#solana/wallet-adapter-base';
import {
//LedgerWalletAdapter,
PhantomWalletAdapter,
SolflareWalletAdapter,
//SlopeWalletAdapter,
//SolletExtensionWalletAdapter,
//SolletWalletAdapter,
//TorusWalletAdapter,
} from '#solana/wallet-adapter-wallets';
import {
WalletModalProvider,
WalletDisconnectButton,
WalletMultiButton
} from '#solana/wallet-adapter-react-ui';
import { clusterApiUrl } from '#solana/web3.js';
// Default styles that can be overridden by your app
require('#solana/wallet-adapter-react-ui/styles.css');
export const Wallet: FC = () => {
// The network can be set to 'devnet', 'testnet', or 'mainnet-beta'.
const network = WalletAdapterNetwork.Devnet;
// You can also provide a custom RPC endpoint.
const endpoint = useMemo(() => clusterApiUrl(network), [network]);
// #solana/wallet-adapter-wallets includes all the adapters but supports tree shaking and lazy loading --
// Only the wallets you configure here will be compiled into your application, and only the dependencies
// of wallets that your users connect to will be loaded.
const wallets = useMemo(
() => [
new PhantomWalletAdapter(),
new SlopeWalletAdapter(),
new SolflareWalletAdapter(),
new TorusWalletAdapter(),
new LedgerWalletAdapter(),
new SolletWalletAdapter({ network }),
new SolletExtensionWalletAdapter({ network }),
],
[network]
);
return (
<ConnectionProvider endpoint={endpoint}>
<WalletProvider wallets={wallets} autoConnect>
<WalletModalProvider>
<WalletMultiButton />
<WalletDisconnectButton />
{ /* Your app's components go here, nested within the context providers. */ }
</WalletModalProvider>
</WalletProvider>
</ConnectionProvider>
);
};
after import modules, I commented some wallet adapters except phantom and solfare
also this code block is so important:
<ConnectionProvider endpoint={endpoint}>
<WalletProvider wallets={wallets} autoConnect>
<WalletModalProvider>
<WalletMultiButton />
<WalletDisconnectButton />
{ /* Your app's components go here, nested within the context
providers. */ }
</WalletModalProvider>
</WalletProvider>
</ConnectionProvider>
modals with functional buttons surrounded by
ConnectionProvider: prepare endpoint for wallets to connecting to and query wallet tokens
WalletProvider: prepare which wallets should be load in modals and ready to connect
and finally usage:
import { WalletNotConnectedError } from '#solana/wallet-adapter-base';
import { useConnection, useWallet } from '#solana/wallet-adapter-react';
import { Keypair, SystemProgram, Transaction } from '#solana/web3.js';
import React, { FC, useCallback } from 'react';
export const SendOneLamportToRandomAddress: FC = () => {
const { connection } = useConnection();
const { publicKey, sendTransaction } = useWallet();
const onClick = useCallback(async () => {
if (!publicKey) throw new WalletNotConnectedError();
const transaction = new Transaction().add(
SystemProgram.transfer({
fromPubkey: publicKey,
toPubkey: Keypair.generate().publicKey,
lamports: 1,
})
);
const signature = await sendTransaction(transaction, connection);
await connection.confirmTransaction(signature, 'processed');
}, [publicKey, sendTransaction, connection]);
return (
<button onClick={onClick} disabled={!publicKey}>
Send 1 lamport to a random address!
</button>
);
};
so as you can see above this part
const { connection } = useConnection();
const { publicKey, sendTransaction } = useWallet();
was prepared for making a connection and give you connected wallet public key and also make use of sendTransaction function of connected wallet, sounds good!
other parts of code are obvous i think.
so, how many functions we have with wallet adapters like phantom? and what functions?
we can get public key, connecting(boolean), connected(boolean), readyState.
also we have some other main functions like:
connect
disconnect
sendTransaction
signTransaction
signAllTransactions
signMessage
you can see all of them in this github repo link
another point is if you use Anchor framework you should know that Anchor uses its own "Wallet" object to interact with the connected wallet and sign transactions on its behalf.
so In order to get an object compatible with Anchor's definition of a wallet, we can use yet another composable called useAnchorWallet. This will return a wallet object that can sign transactions.
const wallet = useAnchorWallet()
have fun

How to debug an import binding name that is not found

I have a NativeScript application that I'm trying to add iBeacon support to using the iBeacon plugin. The application builds successfully and is synced to my phone (I'm using SideKick). When the app runs, it has a fatal javascript exception. The javascript error is reported at:
file:///app/tns_modules/tns-core-modules/ui/builder/builder.js:244:56: JS ERROR Error: Building UI from XML. #file:///app/app-root.xml:18:9
That line is where the page that attempts to access the iBeacon code is defined:
<Frame defaultPage="views/search/search-page"></Frame>
and the specific error is:
Importing binding name 'BeaconLocationOptions' is not found.
I'm assuming this occurs as part of the following import statement:
import {NativescriptIbeacon, BeaconCallback, BeaconLocationOptions, BeaconLocationOptionsIOSAuthType, BeaconLocationOptionsAndroidAuthType, BeaconRegion, Beacon } from 'nativescript-ibeacon';
The above import statement is what is documented as part of the iBeacon documentation.
There is a nativescript-ibeacon directory under node_modules in my project. The specific ios file seems to be there:
/Users/edscott/NativeScript/beacon-test/node_modules/nativescript-ibeacon/nativescript-ibeacon.ios.js
I'm not sure if it is a problem in my code or a problem with configuration - maybe something missing that stops the ibeacon files from being deployed properly to the device.
My code is in javascript, but I have installed the typescript plugin. It looks like this iBeacon plugin assumes the app is written in typescript.
I'm looking for help in determining what to try next.
FYI...I've tried pulling the source files out of the node_modules and incorporating them directly into my project. After resolving many issues with this approach, I eventually hit the same wall - a problem importing the code when running on the device.
Below is the code that is using the iBeacon plugin:
const observableModule = require("tns-core-modules/data/observable");
import {NativescriptIbeacon, BeaconCallback, BeaconLocationOptions, BeaconLocationOptionsIOSAuthType, BeaconLocationOptionsAndroidAuthType, BeaconRegion, Beacon } from 'nativescript-ibeacon';
function SearchViewModel() {
let callback = {
onBeaconManagerReady() {
// start ranging and/or monitoring only when the beacon manager is ready
this.nativescriptIbeacon.startRanging(this.region);
this.nativescriptIbeacon.startMonitoring(this.region);
},
didRangeBeaconsInRegion: function(region, beacons) {
console.log("didRangeBeaconsInRegion");
},
didFailRangingBeaconsInRegion: function(region, errorCode, errorDescription) {
console.log("didFailRangingBeaconsInRegion");
}
};
let options = {
iOSAuthorisationType: BeaconLocationOptionsIOSAuthType.Always,
androidAuthorisationType: BeaconLocationOptionsAndroidAuthType.Coarse,
androidAuthorisationDescription: "Location permission needed"
};
let nativescriptIbeacon = new NativescriptIbeacon(callback, options);
let region = new BeaconRegion("HelloID", "2f234454-cf6d-4a0f-adf2-f4911ba9ffa6");
const viewModel = observableModule.fromObject({
"beaconData": "not set yet",
"onTapStart": function() {
this.set("beaconData", "started");
console.log("tapped start");
if (!nativescriptIbeacon.isAuthorised()) {
console.log("NOT Authorised");
nativescriptIbeacon.requestAuthorization()
.then(() => {
console.log("Authorised by the user");
nativescriptIbeacon.bind();
}, (e) => {
console.log("Authorisation denied by the user");
})
} else {
console.log("Already authorised");
nativescriptIbeacon.bind();
}
},
"onTapStop": function() {
this.set("beaconData", "stopped");
console.log("tapped stop");
nativescriptIbeacon.stopRanging(region);
nativescriptIbeacon.stopMonitoring(region);
nativescriptIbeacon.unbind();
}
});
return viewModel;
}
module.exports = SearchViewModel;
I have created a playground for you here.
If you look into example, I am importing NativescriptIbeacon from the main folder and rest from the common folder.
P.S. This plugin has dependency on nativescript-permission
import { NativescriptIbeacon } from '../nativescript-ibeacon';
import {
BeaconRegion, Beacon, BeaconCallback,
BeaconLocationOptions, BeaconLocationOptionsIOSAuthType, BeaconLocationOptionsAndroidAuthType
} from "../nativescript-ibeacon/nativescript-ibeacon.common";
This answer solved my problem along with another modification. After splitting the import up I still had the same error. Then I read the following page about modules:
https://docs.nativescript.org/core-concepts/android-runtime/getting-started/modules
Based on this statement:
If the module identifier passed to require(moduleName) does not begin
with '/', '../', or './', then NativeScript will lookup the module
within the tns_modules folder
I assumed that maybe only require does the proper lookup into tns_modules.
I refactored the import to use require instead, and that worked. My changes are below. There may be a more efficient way to do this, but it worked for me.
const nsb = require("nativescript-ibeacon/nativescript-ibeacon.js");
const nsbc = require("nativescript-ibeacon/nativescript-ibeacon.common.js");
const NativescriptIbeacon = nsb.NativescriptIbeacon;
const BeaconCallback = nsbc.BeaconCallback;
const BeaconLocationOptions = nsbc.BeaconLocationOptions;
const BeaconLocationOptionsIOSAuthType = nsbc.BeaconLocationOptionsIOSAuthType;
const BeaconLocationOptionsAndroidAuthType = nsbc.BeaconLocationOptionsAndroidAuthType
const BeaconRegion = nsbc.BeaconRegion;
const Beacon = nsbc.Beacon;

Connection between js and akka-http websockets fails 95% of the time

I'm trying to setup a basic connection between an akka-http websocket server and simple javascript.
1 out of roughly 20 connections succeeds, the rest fails. I have no idea why the setup of the connection is so unreliable.
Application.scala:
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.stream.ActorMaterializer
import services.WebService
import scala.concurrent.Await
import scala.concurrent.duration._
import java.util.concurrent.TimeoutException
object Application extends App {
implicit val system = ActorSystem("api")
implicit val materializer = ActorMaterializer()
import system.dispatcher
val config = system.settings.config
val interface = config.getString("app.interface")
val port = config.getInt("app.port")
val service = new WebService
val binding = Http().bindAndHandle(service.route, interface, port)
try {
Await.result(binding, 1 second)
println(s"server online at http://$interface:$port/")
} catch {
case exc: TimeoutException =>
println("Server took to long to startup, shutting down")
system.shutdown()
}
}
WebService.scala:
import actors.{PublisherActor, SubscriberActor}
import akka.actor.{Props, ActorSystem}
import akka.http.scaladsl.model.ws.{Message, TextMessage}
import akka.http.scaladsl.server.Directives
import akka.stream.Materializer
import akka.stream.scaladsl.{Source, Flow}
import scala.concurrent.duration._
class WebService(implicit fm: Materializer, system: ActorSystem) extends Directives {
import system.dispatcher
system.scheduler.schedule(15 second, 15 second) {
println("Timer message!")
}
def route =
get {
pathSingleSlash {
getFromResource("web/index.html")
} ~
path("helloworld") {
handleWebsocketMessages(websocketActorFlow)
}
}
def websocketActorFlow: Flow[Message, Message, Unit] =
Flow[Message].collect({
case TextMessage.Strict(msg) =>
println(msg)
TextMessage.Strict(msg.reverse)
})
}
client side:
<input type="text" id="inputMessage"/><br/>
<input type="button" value="Send!" onClick="sendMessage()"/><br/>
<span id="response"></span>
<script type="application/javascript">
var connection;
function sendMessage() {
connection.send(document.getElementById("inputMessage").value);
}
document.addEventListener("DOMContentLoaded", function (event) {
connection = new WebSocket("ws://localhost:8080/helloworld");
connection.onopen = function (event) {
connection.send("connection established");
};
connection.onmessage = function (event) {
console.log(event.data);
document.getElementById("response").innerHTML = event.data;
}
});
</script>
if the connection to the server fails I get a timeout message after 5 seconds which says the following:
[DEBUG] [07/23/2015 07:59:54.517] [api-akka.actor.default-dispatcher-27] [akka://api/user/$a/flow-76-3-publisherSource-prefixAndTail] Cancelling akka.stream.impl.MultiStreamOutputProcessor$SubstreamOutput#a54778 (after: 5000 ms)
No matter if the connection fails or succeeds, I always get the following log message:
[DEBUG] [07/23/2015 07:59:23.849] [api-akka.actor.default-dispatcher-4] [akka://api/system/IO-TCP/selectors/$a/0] New connection accepted
Look at that error message carefully... it is coming from a source I would not have expected, some "MultiStreamOutputProcessor" when I only expect to handle a single stream.
That tells me - along with the webSocketActorFlow - that maybe you are getting messages and they aren't being caught by the flow, and so you're ending up with substreams you never expected.
So instead of it "only working some of the time," maybe it is "working most of the time but unable to handle all of the input as you have demanded in the flow, and you are left with un-selectable streams that have to die first.
See if you can either a) make sure you get a grip on the streams so you don't end up with stragglers, b) bandaid adjust timeouts, and c) detect such occurences and cancel processing the downstream
https://groups.google.com/forum/#!topic/akka-user/x-tARRaJ0LQ
akka {
stream {
materializer {
subscription-timeout {
timeout=30s
}
}
}
}
http://grokbase.com/t/gg/akka-user/1561gr0jgt/debug-message-cancelling-akka-stream-impl-multistreamoutputprocessor-after-5000-ms

Resources