| // this could be improved... (ex. ignore interfaces/type aliases that describe a parameter type in the same file) | |
| import { Project, TypeGuards, Node } from "ts-morph"; | |
| const project = new Project({ tsConfigFilePath: "tsconfig.json" }); | |
| for (const file of project.getSourceFiles()) { | |
| file.forEachChild(child => { | |
| if (TypeGuards.isVariableStatement(child)) { | |
| if (isExported(child)) | |
| child.getDeclarations().forEach(checkNode); |
| """UDP proxy server.""" | |
| import asyncio | |
| class ProxyDatagramProtocol(asyncio.DatagramProtocol): | |
| def __init__(self, remote_address): | |
| self.remote_address = remote_address | |
| self.remotes = {} |
| """Provide high-level UDP endpoints for asyncio. | |
| Example: | |
| async def main(): | |
| # Create a local UDP enpoint | |
| local = await open_local_endpoint('localhost', 8888) | |
| # Create a remote UDP enpoint, pointing to the first one |
| #!/bin/sh | |
| apt-get -y install git bc | |
| git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt | |
| mkdir /etc/letsencrypt |
| android_binary( | |
| name = 'app', | |
| manifest = 'AndroidManifest.xml', | |
| keystore = ':debug_keystore', | |
| use_split_dex = True, | |
| primary_dex_patterns = [ | |
| '^com/tryroll/roll/AppShell^', | |
| '^com/tryroll/roll/debug/AppShell^', | |
| '^com/tryroll/roll/BuildConfig^', |
| var gulp = require('gulp'); | |
| var sourcemaps = require('gulp-sourcemaps'); | |
| var source = require('vinyl-source-stream'); | |
| var buffer = require('vinyl-buffer'); | |
| var browserify = require('browserify'); | |
| var watchify = require('watchify'); | |
| var babel = require('babelify'); | |
| function compile(watch) { | |
| var bundler = watchify(browserify('./src/index.js', { debug: true }).transform(babel)); |
With the scarecity of IPv4 addresses, and IPv6 still not available at large, NAT traversal is becoming a necessity. Especially with the generalisation of Carrier-grade NATs that you can find on mobile connections. Even with IPv6 you may suffer NAT66. Imagine your mobile device that gets only a single Ipv6 address, and you want to share it on your computer.
The solution might be in a decentralized protocol for address attribution such
| // NOTE: I previously suggested doing this through Grunt, but had plenty of problems with | |
| // my set up. Grunt did some weird things with scope, and I ended up using nodemon. This | |
| // setup is now using Gulp. It works exactly how I expect it to and is WAY more concise. | |
| var gulp = require('gulp'), | |
| spawn = require('child_process').spawn, | |
| node; | |
| /** | |
| * $ gulp server | |
| * description: launch the server. If there's a server already running, kill it. |
| /* | |
| * Copyright (c) 2017 Emil Davtyan | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining | |
| * a copy of this software and associated documentation files (the | |
| * "Software"), to deal in the Software without restriction, including | |
| * without limitation the rights to use, copy, modify, merge, publish, | |
| * distribute, sublicense, and/or sell copies of the Software, and to | |
| * permit persons to whom the Software is furnished to do so, subject to | |
| * the following conditions: |
From Meteor's documentation:
In Meteor, your server code runs in a single thread per request, not in the asynchronous callback style typical of Node. We find the linear execution model a better fit for the typical server code in a Meteor application.
This guide serves as a mini-tour of tools, trix and patterns that can be used to run async code in Meteor.
Sometimes we need to run async code in Meteor.methods. For this we create a Future to block until the async code has finished. This pattern can be seen all over Meteor's own codebase: