async-await 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 452fef45e2da9f4b5f6a48102304e5a06ad501ca084fedba246cff271687828e
-  data.tar.gz: 3d909df655b718a64d0a9b743e0ffe6c2dad06f9481ce22f60ec464ced45eec7
+  metadata.gz: c115c979974936f460f8c73b51c209005bc175fbb3f1d252d46f3257515cbb0a
+  data.tar.gz: 00e46441e57ff43924bc62c3563739bdf036f4f2999aabfe80d54862d5c096e4
 SHA512:
-  metadata.gz: afe87a31cf9cbc63727362839868a7575532f824bae986643bce644e0a04116f7fe44a09049f1e373d537e768105b837575bd011ec1b5dd2983a04453977df37
-  data.tar.gz: 2a67e3c5d77f9290a9372107ed03d55d074f0a66be4af217255534ae59085100e3ecd88485f07f5a45bd4e9109f0160a7391bd56e5cdaebb47dac7ee04bcd34d
+  metadata.gz: b579efc91d103e3819a3928dc370c11403bee51460c0089774e1374f1587a8913a80d745829ebe57cd7f0eaa349732453ab8e7ad06329f2053bfc3c0711dc53b
+  data.tar.gz: d72e8143f192204a6b061ae05f6bc4bb0753e621b69e765e55ecfdc8d21da7a1b0306c88eb5d71841debb6628fdd24f324009176c54922e945b6b0271e5767e4

data/.editorconfig

@@ -2,4 +2,5 @@ root = true
 
 [*]
 indent_style = tab
-indent_size = 4
+indent_size = 2
+

data/.travis.yml

@@ -1,17 +1,18 @@
 language: ruby
-sudo: false
-dist: trusty
 cache: bundler
-rvm:
-  - 2.2
-  - 2.3
-  - 2.4
-  - 2.5
-  - jruby-head
-  - ruby-head
-  - rbx-3
+
 matrix:
+  include:
+    - rvm: 2.3
+    - rvm: 2.4
+    - rvm: 2.5
+    - rvm: 2.6
+    - rvm: 2.6
+      env: COVERAGE=BriefSummary,Coveralls
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: truffleruby
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: rbx-3
+    - rvm: truffleruby

data/Gemfile

@@ -10,7 +10,4 @@ end
 group :test do
 	gem 'benchmark-ips'
 	gem 'ruby-prof', platforms: :mri
-	
-	gem 'simplecov'
-	gem 'coveralls', require: false
 end

data/async-await.gemspec

@@ -19,7 +19,8 @@ Gem::Specification.new do |spec|
 	spec.add_dependency "async", "~> 1.3"
 	spec.add_development_dependency "async-rspec", "~> 1.1"
 
-	spec.add_development_dependency "bundler", "~> 1.15"
+	spec.add_development_dependency "covered"
+	spec.add_development_dependency "bundler"
 	spec.add_development_dependency "rake", "~> 10.0"
 	spec.add_development_dependency "rspec", "~> 3.0"
 end

data/examples/port_scanner/README.md

@@ -0,0 +1,90 @@
+# Port Scanner
+
+A simple `connect`-based port scanner. It scans locahost for all open ports.
+
+## Usage
+
+### Go
+
+Go is pretty awesome, because when the operation would not block, it runs sequentially in the same thread. Go spins up threads and delegates work across available CPU cores.
+
+	$ go get golang.org/x/sync/semaphore
+	$ go build port_scanner.go
+	$ time ./port_scanner
+	22 open
+	139 open
+	445 open
+	3306 open
+	5355 open
+	5432 open
+	6379 open
+	9293 open
+	9292 open
+	9516 open
+	9515 open
+	12046 open
+	12813 open
+	./port_scanner  1.70s user 1.18s system 503% cpu 0.572 total
+
+### Python
+
+Python was the slowest. This is possibly due to the implementation of semaphore. It creates all 65,535 tasks, and then most of them block on the semaphore.
+
+	$ ./port_scanner.py
+	5355 open
+	5432 open
+	3306 open
+	39610 open
+	58260 open
+	12813 open
+	139 open
+	445 open
+	12046 open
+	22 open
+	9292 open
+	9293 open
+	9515 open
+	9516 open
+	6379 open
+	./port_scanner.py  11.41s user 0.88s system 98% cpu 12.485 total
+
+### Ruby
+
+Ruby performance isn't that bad. It's only about half as fast as Go, considering that Go runs across all cores, while the Ruby implementation is limited to one core.
+
+	$ ./port_scanner.rb
+	22 open
+	139 open
+	445 open
+	3306 open
+	5432 open
+	5355 open
+	6379 open
+	9516 open
+	9515 open
+	9293 open
+	9292 open
+	12046 open
+	12813 open
+	./port_scanner.rb  5.99s user 1.18s system 95% cpu 7.543 total
+
+## Notes
+
+### Why do I sometimes see high ports?
+
+Believe it or not, you can connect to your own sockets.
+
+```ruby
+require 'socket'
+a = Addrinfo.tcp("127.0.0.1", 50000)
+s = Socket.new(Socket::AF_INET,  Socket::SOCK_STREAM, 0)
+s.bind(a)
+s.connect(a)
+
+s.write("Hello World")
+=> 11
+[8] pry(main)> s.read(11)
+=> "Hello World"
+```
+
+What's happening is that your socket is implicitly binding to a high port, and at the same time it's trying to connect to it.

data/examples/port_scanner/port_scanner.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"golang.org/x/sync/semaphore"
+	"net"
+	"syscall"
+	"strings"
+	"sync"
+	"time"
+)
+
+// The star of the show, of modest means,
+// used to manage the port scan for a single host.
+type PortScanner struct {
+	ip   string
+	lock *semaphore.Weighted
+}
+
+// Provides a simple wrapper to initializing a PortScanner.
+func NewPortScanner(ip string, limit uint64) *PortScanner {
+	return &PortScanner{
+		ip: ip,
+		lock: semaphore.NewWeighted(int64(limit)),
+	}
+}
+
+// Compute the maximum number of files we can open.
+func FileLimit(max uint64) uint64 {
+	var rlimit syscall.Rlimit
+	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimit)
+	if err != nil {
+		panic(err)
+	}
+	
+	if (max < rlimit.Cur) {
+		return max
+	}
+	
+	return rlimit.Cur
+}
+
+// As the name might suggest, this function checks if a given port
+// is open to TCP communication. Used in conjunction with the Start function
+// to sweep over a range of ports concurrently.
+func checkPortOpen(ip string, port int, timeout time.Duration) {
+	conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", ip, port), timeout)
+
+	if err != nil {
+		if strings.Contains(err.Error(), "timeout") {
+			fmt.Println(port, "timeout", err.Error())
+		} else if strings.Contains(err.Error(), "deadline exceeded") {
+			fmt.Println(port, "timeout", err.Error())
+		} else if strings.Contains(err.Error(), "refused") {
+			// fmt.Println(port, "closed", err.Error())
+		} else {
+			panic(err)
+		}
+		return
+	}
+
+	fmt.Println(port, "open")
+	conn.Close()
+}
+
+// This function is the bread and butter of this script. It manages the
+// port scanning for a given range of ports with the given timeout value
+// to deal with filtered ports by a firewall typically.
+func (ps *PortScanner) Start(start, stop int, timeout time.Duration) {
+	wg := sync.WaitGroup{}
+	defer wg.Wait()
+
+	for port := start; port <= stop; port++ {
+
+		ctx := context.TODO()
+
+		for {
+			err := ps.lock.Acquire(ctx, 1)
+			if err == nil {
+				break
+			}
+		}
+
+		wg.Add(1)
+
+		go func(ip string, port int) {
+			defer ps.lock.Release(1)
+			defer wg.Done()
+
+			checkPortOpen(ps.ip, port, timeout)
+		}(ps.ip, port)
+
+	}
+}
+
+// This function kicks off the whole shindig' and provides a
+// basic example of the internal API usage.
+func main() {
+	batch_size := FileLimit(512)
+	
+	// Create a new PortScanner for localhost.
+	ps := NewPortScanner("127.0.0.1", batch_size)
+
+	// Start scanning all the ports on localhost.
+	ps.Start(1, 65535, 1000*time.Millisecond)
+}

data/examples/port_scanner/port_scanner.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+import os, resource
+import asyncio
+
+class PortScanner:
+    def __init__(self, host="0.0.0.0", ports=range(1, 1024+1), batch_size=1024):
+        self.host       = host
+        self.ports      = ports
+        self.semaphore  = asyncio.Semaphore(value=batch_size)
+        self.loop       = asyncio.get_event_loop()
+
+    async def scan_port(self, port, timeout):
+        async with self.semaphore:
+            try:
+                future = asyncio.open_connection(self.host, port, loop=self.loop)
+                reader, writer = await asyncio.wait_for(future, timeout=timeout)
+                print("{} open".format(port))
+                writer.close()
+            except ConnectionRefusedError:
+                pass
+                # print("{} closed".format(port))
+            except asyncio.TimeoutError:
+                print("{} timeout".format(port))
+
+    def start(self, timeout=1.0):
+        self.loop.run_until_complete(asyncio.gather(
+            *[self.scan_port(port, timeout) for port in self.ports]
+            ))
+
+limits = resource.getrlimit(resource.RLIMIT_NOFILE)
+batch_size = min(512, limits[0])
+
+scanner = PortScanner(host="127.0.0.1", ports=range(1, 65535+1), batch_size=batch_size)
+
+scanner.start()

data/examples/port_scanner/port_scanner.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'async/io'
+require 'async/semaphore'
+require_relative '../../lib/async/await'
+
+class PortScanner
+  include Async::Await
+  include Async::IO
+
+  def initialize(host: '0.0.0.0', ports:, batch_size: 1024)
+    @host      = host
+    @ports     = ports
+    @semaphore = Async::Semaphore.new(batch_size)
+  end
+
+  def scan_port(port, timeout)
+    with_timeout(timeout) do
+      address = Async::IO::Address.tcp(@host, port)
+      peer = Socket.connect(address)
+      puts "#{port} open"
+      peer.close
+    end
+  rescue Errno::ECONNREFUSED
+    # puts "#{port} closed"
+  rescue Async::TimeoutError
+    puts "#{port} timeout"
+  end
+
+  async def start(timeout = 1.0)
+    @ports.map do |port|
+      @semaphore.async do
+        scan_port(port, timeout)
+      end
+    end.collect(&:result)
+  end
+end
+
+limits = Process.getrlimit(Process::RLIMIT_NOFILE)
+batch_size = [512, limits.first].min
+
+scanner = PortScanner.new(host: "127.0.0.1", ports: Range.new(1, 65535), batch_size: batch_size)
+
+scanner.start

data/lib/async/await/methods.rb

@@ -29,7 +29,7 @@ module Async
 				Async::Task.current
 			end
 
-			def_delegators :task, :timeout, :sleep, :async
+			def_delegators :task, :with_timeout, :sleep, :async
 
 			def await(&block)
 				block.call.wait

data/lib/async/await/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module Await
-		VERSION = "0.2.0"
+		VERSION = "0.3.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-await
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-19 00:00:00.000000000 Z
+date: 2019-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -38,20 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: covered
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -97,6 +111,10 @@ files:
 - async-await.gemspec
 - examples/chickens.rb
 - examples/echo.rb
+- examples/port_scanner/README.md
+- examples/port_scanner/port_scanner.go
+- examples/port_scanner/port_scanner.py
+- examples/port_scanner/port_scanner.rb
 - examples/sleep_sort.rb
 - lib/async/await.rb
 - lib/async/await/methods.rb
@@ -119,8 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Implements the async/await pattern on top of async :)