├── lib
    ├── Godeps
    │   ├── _workspace
    │   │   ├── .gitignore
    │   │   └── src
    │   │   │   └── github.com
    │   │   │       ├── lib
    │   │   │           └── pq
    │   │   │           │   ├── .gitignore
    │   │   │           │   ├── oid
    │   │   │           │       ├── doc.go
    │   │   │           │       └── gen.go
    │   │   │           │   ├── certs
    │   │   │           │       ├── README
    │   │   │           │       ├── postgresql.key
    │   │   │           │       ├── root.crt
    │   │   │           │       └── server.key
    │   │   │           │   ├── user_posix.go
    │   │   │           │   ├── user_windows.go
    │   │   │           │   ├── LICENSE.md
    │   │   │           │   ├── conn_xact_test.go
    │   │   │           │   ├── CONTRIBUTING.md
    │   │   │           │   ├── url_test.go
    │   │   │           │   ├── buf.go
    │   │   │           │   ├── url.go
    │   │   │           │   └── README.md
    │   │   │       ├── pebbe
    │   │   │           └── zmq4
    │   │   │           │   ├── examples_security
    │   │   │           │       ├── Makefile
    │   │   │           │       ├── README.md
    │   │   │           │       ├── grasslands.go
    │   │   │           │       ├── woodhouse.go
    │   │   │           │       ├── strawhouse.go
    │   │   │           │       ├── ironhouse.go
    │   │   │           │       └── stonehouse.go
    │   │   │           │   ├── examples
    │   │   │           │       ├── README.md
    │   │   │           │       ├── version.go
    │   │   │           │       ├── udpping3.go
    │   │   │           │       ├── eagain.go
    │   │   │           │       ├── psenvsub.go
    │   │   │           │       ├── rrclient.go
    │   │   │           │       ├── psenvpub.go
    │   │   │           │       ├── flserver1.go
    │   │   │           │       ├── wuproxy.go
    │   │   │           │       ├── mdworker.go
    │   │   │           │       ├── clonecli1.go
    │   │   │           │       ├── mdclient.go
    │   │   │           │       ├── hwserver.go
    │   │   │           │       ├── mmiecho.go
    │   │   │           │       ├── rrworker.go
    │   │   │           │       ├── mdapi
    │   │   │           │       │   └── const.go
    │   │   │           │       ├── hwclient.go
    │   │   │           │       ├── msgqueue.go
    │   │   │           │       ├── flserver2.go
    │   │   │           │       ├── mdclient2.go
    │   │   │           │       ├── pathosub.go
    │   │   │           │       ├── tasksink.go
    │   │   │           │       ├── flclient3.go
    │   │   │           │       ├── clonesrv1.go
    │   │   │           │       ├── wuserver.go
    │   │   │           │       ├── clonecli6.go
    │   │   │           │       ├── lpserver.go
    │   │   │           │       ├── taskwork.go
    │   │   │           │       ├── pathopub.go
    │   │   │           │       ├── tasksink2.go
    │   │   │           │       ├── syncsub.go
    │   │   │           │       ├── mspoller.go
    │   │   │           │       ├── wuclient.go
    │   │   │           │       ├── rrbroker.go
    │   │   │           │       ├── bstarsrv2.go
    │   │   │           │       ├── mtrelay.go
    │   │   │           │       ├── mtserver.go
    │   │   │           │       ├── msreader.go
    │   │   │           │       ├── kvsimple
    │   │   │           │       │   └── kvsimple_test.go
    │   │   │           │       ├── interrupt.go
    │   │   │           │       ├── taskvent.go
    │   │   │           │       ├── flserver3.go
    │   │   │           │       ├── udpping2.go
    │   │   │           │       ├── spworker.go
    │   │   │           │       ├── identity.go
    │   │   │           │       ├── taskwork2.go
    │   │   │           │       ├── syncpub.go
    │   │   │           │       ├── peering1.go
    │   │   │           │       ├── lvcache.go
    │   │   │           │       ├── rtreq.go
    │   │   │           │       ├── clonecli2.go
    │   │   │           │       ├── ticlient.go
    │   │   │           │       ├── rtdealer.go
    │   │   │           │       ├── suisnail.go
    │   │   │           │       ├── flclient1.go
    │   │   │           │       ├── tripping.go
    │   │   │           │       ├── clonecli4.go
    │   │   │           │       ├── clonesrv3.go
    │   │   │           │       ├── clonecli3.go
    │   │   │           │       ├── clonecli5.go
    │   │   │           │       ├── fileio2.go
    │   │   │           │       ├── spqueue.go
    │   │   │           │       ├── espresso.go
    │   │   │           │       ├── bstarcli.go
    │   │   │           │       ├── fileio1.go
    │   │   │           │       ├── clonesrv4.go
    │   │   │           │       ├── lpclient.go
    │   │   │           │       ├── kvmsg
    │   │   │           │       │   └── kvmsg_test.go
    │   │   │           │       ├── udpping1.go
    │   │   │           │       └── fileio3.go
    │   │   │           │   ├── socketget_unix.go
    │   │   │           │   ├── zmq4.h
    │   │   │           │   ├── socketget_windows.go
    │   │   │           │   ├── doc.go
    │   │   │           │   ├── socketevent_test.go
    │   │   │           │   ├── LICENSE.txt
    │   │   │           │   ├── README.md
    │   │   │           │   └── errors.go
    │   │   │       ├── darkhelmet
    │   │   │           └── twitterstream
    │   │   │           │   ├── format.bash
    │   │   │           │   ├── README.md
    │   │   │           │   ├── .gitignore
    │   │   │           │   ├── index_pair.go
    │   │   │           │   ├── LICENSE.md
    │   │   │           │   ├── time.go
    │   │   │           │   ├── place.go
    │   │   │           │   ├── connection.go
    │   │   │           │   └── coordinates.go
    │   │   │       ├── stretchr
    │   │   │           └── testify
    │   │   │           │   └── assert
    │   │   │           │       └── errors.go
    │   │   │       ├── golang
    │   │   │           └── protobuf
    │   │   │           │   └── proto
    │   │   │           │       ├── Makefile
    │   │   │           │       ├── proto3_proto
    │   │   │           │           ├── Makefile
    │   │   │           │           └── proto3.proto
    │   │   │           │       ├── testdata
    │   │   │           │           └── Makefile
    │   │   │           │       ├── size2_test.go
    │   │   │           │       └── message_set_test.go
    │   │   │       └── garyburd
    │   │   │           └── go-oauth
    │   │   │               └── oauth
    │   │   │                   └── examples_test.go
    │   ├── Readme
    │   └── Godeps.json
    ├── example
    │   ├── receiver.go
    │   ├── feed.go
    │   └── publisher.go
    ├── feed_test.go
    ├── network_test.go
    ├── transform_test.go
    ├── feed.go
    └── transform.go
├── website
    ├── www
    │   ├── src
    │   │   ├── js
    │   │   │   ├── lib
    │   │   │   │   ├── c3.d.ts
    │   │   │   │   ├── twemoji.d.ts
    │   │   │   │   ├── inject.js
    │   │   │   │   └── bootstrap.d.ts
    │   │   │   ├── App.ts
    │   │   │   ├── Overlay.ts
    │   │   │   ├── API.ts
    │   │   │   ├── Map.ts
    │   │   │   ├── Feed.ts
    │   │   │   ├── Chart.ts
    │   │   │   └── Tweet.ts
    │   │   ├── css
    │   │   │   ├── chart.less
    │   │   │   ├── style.less
    │   │   │   ├── leaflet.less
    │   │   │   ├── bootstrap.less
    │   │   │   └── tweetmap.less
    │   │   └── bower.json
    │   ├── tsconfig.json
    │   ├── tweetmap.sublime-project
    │   ├── package.json
    │   └── tslint.json
    ├── log.go
    ├── main.go
    └── handlers.go
├── .gitignore
├── protobuf
    └── prototweet.proto
├── LICENSE
├── README.md
└── .travis.yml


/lib/Godeps/_workspace/.gitignore:
--------------------------------------------------------------------------------
1 | /pkg
2 | /bin
3 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/.gitignore:
--------------------------------------------------------------------------------
1 | .db
2 | *.test
3 | *~
4 | *.swp
5 | 


--------------------------------------------------------------------------------
/website/www/src/js/lib/c3.d.ts:
--------------------------------------------------------------------------------
1 | declare module c3 {
2 | 	function generate(i: any): any;
3 | }


--------------------------------------------------------------------------------
/website/www/src/js/lib/twemoji.d.ts:
--------------------------------------------------------------------------------
1 | declare module twemoji {
2 | 	function parse(data: string): string;
3 | }


--------------------------------------------------------------------------------
/website/www/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |     "compilerOptions" : {
3 |         "target" : "es5",
4 |         "module" : "commonjs"
5 |     }
6 | }


--------------------------------------------------------------------------------
/website/www/src/css/chart.less:
--------------------------------------------------------------------------------
1 | .c3-axis {
2 | 	fill: @list-group-bg;
3 | }
4 | 
5 | .c3 path, .c3 line{
6 | 	stroke: darken(@body-bg, 15%);
7 | }
8 | 


--------------------------------------------------------------------------------
/website/www/src/js/lib/inject.js:
--------------------------------------------------------------------------------
1 | document.write('<script src="http://' + window.location.hostname + ':35729/livereload.js?snipver=1" type="text/javascript"><\/script>')


--------------------------------------------------------------------------------
/lib/Godeps/Readme:
--------------------------------------------------------------------------------
1 | This directory tree is generated automatically by godep.
2 | 
3 | Please do not edit.
4 | 
5 | See https://github.com/tools/godep for more information.
6 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples_security/Makefile:
--------------------------------------------------------------------------------
1 | 
2 | % : %.go
3 | 	go build $<
4 | 
5 | all: grasslands strawhouse woodhouse stonehouse ironhouse
6 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/README.md:
--------------------------------------------------------------------------------
1 | These are examples from [ØMQ - The Guide](http://zguide.zeromq.org/page:all), 
2 | re-implemented for the current Go package.
3 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/format.bash:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | for file in `git ls-files | egrep '.*\.go$'`; do
4 |     gofmt -tabs=false -tabwidth 4 -w $file
5 | done
6 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/oid/doc.go:
--------------------------------------------------------------------------------
1 | // Package oid contains OID constants
2 | // as defined by the Postgres server.
3 | package oid
4 | 
5 | // Oid is a Postgres Object ID.
6 | type Oid uint32
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | website/website
 2 | *.sublime-workspace
 3 | */loaderio*
 4 | *.out
 5 | node_modules
 6 | dist
 7 | bower_components
 8 | types/*
 9 | watcher/*
10 | database/postgres_data
11 | */coverage.html
12 | *.sh
13 | *.swp
14 | 


--------------------------------------------------------------------------------
/website/www/src/css/style.less:
--------------------------------------------------------------------------------
1 | @import url(http://fonts.googleapis.com/css?family=Nova+Square|Roboto:400,700,400italic);
2 | @import "bootstrap.less";
3 | @import "tweetmap.less";
4 | @import "leaflet.less";
5 | @import "chart.less";


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/certs/README:
--------------------------------------------------------------------------------
1 | This directory contains certificates and private keys for testing some
2 | SSL-related functionality in Travis.  Do NOT use these certificates for
3 | anything other than testing.
4 | 


--------------------------------------------------------------------------------
/website/www/src/css/leaflet.less:
--------------------------------------------------------------------------------
 1 | .leaflet-popup-content-wrapper, .leaflet-popup-tip, .leaflet-bar a {
 2 | 	background: lighten(@body-bg, 5%);
 3 | 	color: #FFF;
 4 | }
 5 | 
 6 | .leaflet-bar a {
 7 | 	border-bottom-color: @body-bg;
 8 | }
 9 | 
10 | .leaflet-container a {
11 | 	color: lighten(@text-muted, 10%);
12 | }


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/version.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Report 0MQ version.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | )
12 | 
13 | func main() {
14 | 	major, minor, patch := zmq.Version()
15 | 	fmt.Printf("Current 0MQ version is %d.%d.%d\n", major, minor, patch)
16 | }
17 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/README.md:
--------------------------------------------------------------------------------
 1 | # twitterstream
 2 | 
 3 | Twitter streaming API for Go. [Documentation](http://go.pkgdoc.org/github.com/darkhelmet/twitterstream)
 4 | 
 5 | See `twimgd.go` for an example that downloads images given keywords.
 6 | 
 7 | # License
 8 | 
 9 | Copyright © 2012 Daniel Huckstep. See LICENSE for details.
10 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/socketget_unix.go:
--------------------------------------------------------------------------------
 1 | // +build !windows
 2 | 
 3 | package zmq4
 4 | 
 5 | /*
 6 | #include <zmq.h>
 7 | */
 8 | import "C"
 9 | 
10 | // ZMQ_FD: Retrieve file descriptor associated with the socket
11 | //
12 | // See: http://api.zeromq.org/4-0:zmq-getsockopt#toc24
13 | func (soc *Socket) GetFd() (int, error) {
14 | 	return soc.getInt(C.ZMQ_FD)
15 | }
16 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/user_posix.go:
--------------------------------------------------------------------------------
 1 | // Package pq is a pure Go Postgres driver for the database/sql package.
 2 | 
 3 | // +build darwin freebsd linux nacl netbsd openbsd solaris
 4 | 
 5 | package pq
 6 | 
 7 | import "os/user"
 8 | 
 9 | func userCurrent() (string, error) {
10 | 	u, err := user.Current()
11 | 	if err != nil {
12 | 		return "", err
13 | 	}
14 | 	return u.Username, nil
15 | }
16 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/stretchr/testify/assert/errors.go:
--------------------------------------------------------------------------------
 1 | package assert
 2 | 
 3 | import (
 4 | 	"errors"
 5 | )
 6 | 
 7 | // AnError is an error instance useful for testing.  If the code does not care
 8 | // about error specifics, and only needs to return the error for example, this
 9 | // error should be used to make the test code more readable.
10 | var AnError = errors.New("assert.AnError general error for testing")
11 | 


--------------------------------------------------------------------------------
/website/www/tweetmap.sublime-project:
--------------------------------------------------------------------------------
 1 | {
 2 |     "folders": [
 3 |         {
 4 |             "path": "G:\\Dropbox\\Projects\\tweetmap\\website\\www", 
 5 |             "follow_symlinks": true
 6 |         }, 
 7 |         {
 8 |             "path": ".", 
 9 |             "follow_symlinks": true
10 |         }
11 |     ], 
12 |     "settings": {
13 |         "typescript": {
14 |             "roots": [
15 |                 "src/js/App.ts"
16 |             ]
17 |         }
18 |     }
19 | }


--------------------------------------------------------------------------------
/website/log.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"io"
 5 | 	"log"
 6 | )
 7 | 
 8 | var (
 9 | 	Info    *log.Logger
10 | 	Warning *log.Logger
11 | 	Error   *log.Logger
12 | )
13 | 
14 | func initLogger(infoH io.Writer, warningH io.Writer, errorH io.Writer) {
15 | 	Info = log.New(infoH, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
16 | 	Warning = log.New(warningH, "WARNING: ", log.Ldate|log.Ltime|log.Lshortfile)
17 | 	Error = log.New(errorH, "WARNING: ", log.Ldate|log.Ltime|log.Lshortfile)
18 | }
19 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/udpping3.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  UDP ping command
 3 | //  Model 3, uses abstract network interface
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	"github.com/pebbe/zmq4/examples/intface"
10 | 
11 | 	"fmt"
12 | 	"log"
13 | )
14 | 
15 | func main() {
16 | 	log.SetFlags(log.Lshortfile)
17 | 	iface := intface.New()
18 | 	for {
19 | 		msg, err := iface.Recv()
20 | 		if err != nil {
21 | 			log.Fatalln(err)
22 | 		}
23 | 		fmt.Printf("%q\n", msg)
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/zmq4.h:
--------------------------------------------------------------------------------
 1 | #if ZMQ_VERSION_MINOR < 1
 2 | #define ZMQ_ROUTER_HANDOVER 0
 3 | #define ZMQ_TOS 0
 4 | #define ZMQ_IPC_FILTER_PID 0
 5 | #define ZMQ_IPC_FILTER_UID 0
 6 | #define ZMQ_IPC_FILTER_GID 0
 7 | #define ZMQ_CONNECT_RID 0
 8 | #define ZMQ_GSSAPI_SERVER 0
 9 | #define ZMQ_GSSAPI_PRINCIPAL 0
10 | #define ZMQ_GSSAPI_SERVICE_PRINCIPAL 0
11 | #define ZMQ_GSSAPI_PLAINTEXT 0
12 | #define ZMQ_HANDSHAKE_IVL 0
13 | #define ZMQ_SOCKS_PROXY 0
14 | #define ZMQ_XPUB_NODROP 0
15 | #endif
16 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/index_pair.go:
--------------------------------------------------------------------------------
 1 | package twitterstream
 2 | 
 3 | import (
 4 |     "encoding/json"
 5 | )
 6 | 
 7 | type IndexPair struct {
 8 |     Start int
 9 |     End   int
10 | }
11 | 
12 | func (i IndexPair) MarshalJSON() ([]byte, error) {
13 |     pair := []int{i.Start, i.End}
14 |     return json.Marshal(pair)
15 | }
16 | 
17 | func (i *IndexPair) UnmarshalJSON(data []byte) error {
18 |     pair := [2]int{}
19 |     err := json.Unmarshal(data, &pair)
20 |     if err != nil {
21 |         return err
22 |     }
23 |     i.Start = pair[0]
24 |     i.End = pair[1]
25 |     return nil
26 | }
27 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples_security/README.md:
--------------------------------------------------------------------------------
 1 | These are Go versions of the C examples described in
 2 | [Using ZeroMQ Security (part 2)](http://hintjens.com/blog:49) by Pieter Hintjens.
 3 | Those C examples use the [zauth module](http://czmq.zeromq.org/manual:zauth)
 4 | in the [czmq library](http://czmq.zeromq.org).
 5 | 
 6 | There are some differences:
 7 | 
 8 |  * The zauth module doesn't handle domains. The Go version does.
 9 |  * The zauth module handles files with usernames/passwords and directories with certificates.
10 |    The Go version just uses maps of usernames/passwords and lists of public user keys.
11 | 


--------------------------------------------------------------------------------
/lib/example/receiver.go:
--------------------------------------------------------------------------------
 1 | // Package main provides ...
 2 | package main
 3 | 
 4 | import (
 5 | 	"github.com/cdn-madness/tweetmap/lib"
 6 | 	"log"
 7 | )
 8 | 
 9 | const CONNSTR string = "tcp://127.0.0.1:7654"
10 | 
11 | func main() {
12 | 	// First set up the channels
13 | 	doneChan := make(chan bool)
14 | 
15 | 	tweetChan, errChan := tweetmap.InitReceiver(CONNSTR, doneChan)
16 | 
17 | 	for {
18 | 		select {
19 | 		case tweet := <-tweetChan:
20 | 			log.Println("Received tweet from @" + tweet.User.GetName())
21 | 		case err := <-errChan:
22 | 			close(doneChan)
23 | 			log.Printf("ERROR! %s", err.Error())
24 | 		}
25 | 	}
26 | 	close(doneChan)
27 | }
28 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/eagain.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Shows how to provoke EAGAIN when reaching HWM
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | )
12 | 
13 | func main() {
14 | 
15 | 	mailbox, _ := zmq.NewSocket(zmq.DEALER)
16 | 	mailbox.SetSndhwm(4)
17 | 	mailbox.SetSndtimeo(0)
18 | 	mailbox.Connect("tcp://localhost:9876")
19 | 
20 | 	for count := 0; count < 10; count++ {
21 | 		fmt.Println("Sending message", count)
22 | 		_, err := mailbox.SendMessage(fmt.Sprint("message ", count))
23 | 		if err != nil {
24 | 			fmt.Println(err)
25 | 			break
26 | 		}
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/socketget_windows.go:
--------------------------------------------------------------------------------
 1 | // +build windows
 2 | 
 3 | package zmq4
 4 | 
 5 | /*
 6 | #include <zmq.h>
 7 | */
 8 | import "C"
 9 | 
10 | import (
11 | 	"unsafe"
12 | )
13 | 
14 | /*
15 | ZMQ_FD: Retrieve file descriptor associated with the socket
16 | 
17 | See: http://api.zeromq.org/4-0:zmq-getsockopt#toc24
18 | */
19 | func (soc *Socket) GetFd() (uintptr, error) {
20 | 	value := C.SOCKET(0)
21 | 	size := C.size_t(unsafe.Sizeof(value))
22 | 	if i, err := C.zmq_getsockopt(soc.soc, C.ZMQ_FD, unsafe.Pointer(&value), &size); i != 0 {
23 | 		return uintptr(0), errget(err)
24 | 	}
25 | 	return uintptr(value), nil
26 | }
27 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/psenvsub.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Pubsub envelope subscriber.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | )
12 | 
13 | func main() {
14 | 	//  Prepare our subscriber
15 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
16 | 	defer subscriber.Close()
17 | 	subscriber.Connect("tcp://localhost:5563")
18 | 	subscriber.SetSubscribe("B")
19 | 
20 | 	for {
21 | 		//  Read envelope with address
22 | 		address, _ := subscriber.Recv(0)
23 | 		//  Read message contents
24 | 		contents, _ := subscriber.Recv(0)
25 | 		fmt.Printf("[%s] %s\n", address, contents)
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/rrclient.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Request-reply client.
 3 | //  Connects REQ socket to tcp://localhost:5559
 4 | //  Sends "Hello" to server, expects "World" back
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | )
14 | 
15 | func main() {
16 | 	requester, _ := zmq.NewSocket(zmq.REQ)
17 | 	defer requester.Close()
18 | 	requester.Connect("tcp://localhost:5559")
19 | 
20 | 	for request := 0; request < 10; request++ {
21 | 		requester.Send("Hello", 0)
22 | 		reply, _ := requester.Recv(0)
23 | 		fmt.Printf("Received reply %d [%s]\n", request, reply)
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/LICENSE.md:
--------------------------------------------------------------------------------
 1 | Copyright 2011 Daniel Huckstep
 2 | 
 3 | Licensed under the Apache License, Version 2.0 (the "License");
 4 | you may not use this file except in compliance with the License.
 5 | You may obtain a copy of the License at
 6 | 
 7 |    http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/psenvpub.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Pubsub envelope publisher.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"time"
11 | )
12 | 
13 | func main() {
14 | 	//  Prepare our publisher
15 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
16 | 	defer publisher.Close()
17 | 	publisher.Bind("tcp://*:5563")
18 | 
19 | 	for {
20 | 		//  Write two messages, each with an envelope and content
21 | 		publisher.Send("A", zmq.SNDMORE)
22 | 		publisher.Send("We don't want to see this", 0)
23 | 		publisher.Send("B", zmq.SNDMORE)
24 | 		publisher.Send("We would like to see this", 0)
25 | 		time.Sleep(time.Second)
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/time.go:
--------------------------------------------------------------------------------
 1 | package twitterstream
 2 | 
 3 | import (
 4 |     "encoding/json"
 5 |     "time"
 6 | )
 7 | 
 8 | const (
 9 |     TimeFormat = "Mon Jan _2 15:04:05 +0000 2006"
10 | )
11 | 
12 | type Time struct {
13 |     time.Time
14 | }
15 | 
16 | func (t Time) MarshalJSON() ([]byte, error) {
17 |     formatted := t.Time.Format(TimeFormat)
18 |     return json.Marshal(formatted)
19 | }
20 | 
21 | func (t *Time) UnmarshalJSON(data []byte) error {
22 |     var s string
23 |     err := json.Unmarshal(data, &s)
24 |     if err != nil {
25 |         return err
26 |     }
27 |     t.Time, err = time.Parse(TimeFormat, s)
28 |     return nil
29 | }
30 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/flserver1.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Freelance server - Model 1.
 3 | //  Trivial echo service
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"os"
13 | )
14 | 
15 | func main() {
16 | 	if len(os.Args) < 2 {
17 | 		fmt.Printf("I: syntax: %s <endpoint>\n", os.Args[0])
18 | 		return
19 | 	}
20 | 	server, _ := zmq.NewSocket(zmq.REP)
21 | 	server.Bind(os.Args[1])
22 | 
23 | 	fmt.Println("I: echo service is ready at", os.Args[1])
24 | 	for {
25 | 		msg, err := server.RecvMessage(0)
26 | 		if err != nil {
27 | 			break //  Interrupted
28 | 		}
29 | 		server.SendMessage(msg)
30 | 	}
31 | 	fmt.Println("W: interrupted")
32 | }
33 | 


--------------------------------------------------------------------------------
/website/www/src/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "tweetmap",
 3 |   "version": "0.0.1",
 4 |   "homepage": "https://github.com/cdn-madness/tweetmap",
 5 |   "authors": [
 6 |     "Alex Urquhart <alexurquhart@gmail.com>"
 7 |   ],
 8 |   "description": "Ottawa Tweet Mapper",
 9 |   "main": "index.html",
10 |   "keywords": [
11 |     "tweet"
12 |   ],
13 |   "license": "MIT",
14 |   "ignore": [
15 |     "**/.*",
16 |     "node_modules",
17 |     "bower_components",
18 |     "test",
19 |     "tests"
20 |   ],
21 |   "dependencies": {
22 |     "Leaflet.awesome-markers": "~2.0.2",
23 |     "flot": "~0.8.3",
24 |     "d3-cloud": "~1.0.5",
25 |     "bootstrap": "~3.3.2",
26 |     "malihu-custom-scrollbar-plugin": "~3.0.7"
27 |   }
28 | }
29 | 


--------------------------------------------------------------------------------
/website/www/src/js/App.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="lib/knockout.d.ts"/>
 2 | /// <reference path="lib/jquery.d.ts"/>
 3 | /// <reference path="lib/bootstrap.d.ts"/>
 4 | 
 5 | /// <reference path="Feed.ts"/>
 6 | /// <reference path="Map.ts"/>
 7 | /// <reference path="ViewModel.ts"/>
 8 | 
 9 | function resizeSidebar(): void {
10 | 	var sideHeight: number = $('#left-sidebar').height();
11 | 	var headerHeight: number = $('#tab-header').height();
12 | 	$('.tab-content').height(sideHeight - headerHeight);
13 | }
14 | 
15 | $(function(): void {
16 | 	// Resize the tab content
17 | 	resizeSidebar();
18 | 	$(window).resize(resizeSidebar);
19 | 
20 | 	var vm: ViewModel = new ViewModel();
21 | 
22 | 	ko.applyBindings(vm);
23 | 
24 | 	return;
25 | });
26 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/wuproxy.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Weather proxy device.
 3 | //
 4 | //  NOT TESTED
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"log"
13 | )
14 | 
15 | func main() {
16 | 	//  This is where the weather server sits
17 | 	frontend, _ := zmq.NewSocket(zmq.XSUB)
18 | 	defer frontend.Close()
19 | 	frontend.Connect("tcp://192.168.55.210:5556")
20 | 
21 | 	//  This is our public endpoint for subscribers
22 | 	backend, _ := zmq.NewSocket(zmq.XPUB)
23 | 	defer backend.Close()
24 | 	backend.Bind("tcp://10.1.1.0:8100")
25 | 
26 | 	//  Run the proxy until the user interrupts us
27 | 	err := zmq.Proxy(frontend, backend, nil)
28 | 	log.Fatalln("Proxy interrupted:", err)
29 | }
30 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/doc.go:
--------------------------------------------------------------------------------
 1 | /*
 2 | A Go interface to ZeroMQ (zmq, 0mq) version 4.
 3 | 
 4 | For ZeroMQ version 3, see: http://github.com/pebbe/zmq3
 5 | 
 6 | For ZeroMQ version 2, see: http://github.com/pebbe/zmq2
 7 | 
 8 | http://www.zeromq.org/
 9 | 
10 | See also the wiki: https://github.com/pebbe/zmq4/wiki
11 | 
12 | A note on the use of a context:
13 | 
14 | This package provides a default context. This is what will be used by
15 | the functions without a context receiver, that create a socket or
16 | manipulate the context. Package developers that import this package
17 | should probably not use the default context with its associated
18 | functions, but create their own context(s). See: type Context.
19 | */
20 | package zmq4
21 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mdworker.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Majordomo Protocol worker example.
 3 | //  Uses the mdwrk API to hide all MDP aspects
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	"github.com/pebbe/zmq4/examples/mdapi"
10 | 
11 | 	"log"
12 | 	"os"
13 | )
14 | 
15 | func main() {
16 | 	var verbose bool
17 | 	if len(os.Args) > 1 && os.Args[1] == "-v" {
18 | 		verbose = true
19 | 	}
20 | 	session, _ := mdapi.NewMdwrk("tcp://localhost:5555", "echo", verbose)
21 | 
22 | 	var err error
23 | 	var request, reply []string
24 | 	for {
25 | 		request, err = session.Recv(reply)
26 | 		if err != nil {
27 | 			break //  Worker was interrupted
28 | 		}
29 | 		reply = request //  Echo is complex... :-)
30 | 	}
31 | 	log.Println(err)
32 | }
33 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonecli1.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone client Model One
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/kvsimple"
10 | 
11 | 	"fmt"
12 | )
13 | 
14 | func main() {
15 | 	//  Prepare our context and updates socket
16 | 	updates, _ := zmq.NewSocket(zmq.SUB)
17 | 	updates.SetSubscribe("")
18 | 	updates.Connect("tcp://localhost:5556")
19 | 
20 | 	kvmap := make(map[string]*kvsimple.Kvmsg)
21 | 
22 | 	sequence := int64(0)
23 | 	for ; true; sequence++ {
24 | 		kvmsg, err := kvsimple.RecvKvmsg(updates)
25 | 		if err != nil {
26 | 			break //  Interrupted
27 | 		}
28 | 		kvmsg.Store(kvmap)
29 | 	}
30 | 	fmt.Printf("Interrupted\n%d messages in\n", sequence)
31 | }
32 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mdclient.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Majordomo Protocol client example.
 3 | //  Uses the mdcli API to hide all MDP aspects
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	"github.com/pebbe/zmq4/examples/mdapi"
10 | 
11 | 	"fmt"
12 | 	"log"
13 | 	"os"
14 | )
15 | 
16 | func main() {
17 | 	var verbose bool
18 | 	if len(os.Args) > 1 && os.Args[1] == "-v" {
19 | 		verbose = true
20 | 	}
21 | 	session, _ := mdapi.NewMdcli("tcp://localhost:5555", verbose)
22 | 
23 | 	count := 0
24 | 	for ; count < 100000; count++ {
25 | 		_, err := session.Send("echo", "Hello world")
26 | 		if err != nil {
27 | 			log.Println(err)
28 | 			break //  Interrupt or failure
29 | 		}
30 | 	}
31 | 	fmt.Printf("%d requests/replies processed\n", count)
32 | }
33 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/hwserver.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Hello World server.
 3 | //  Binds REP socket to tcp://*:5555
 4 | //  Expects "Hello" from client, replies with "World"
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"time"
14 | )
15 | 
16 | func main() {
17 | 	//  Socket to talk to clients
18 | 	responder, _ := zmq.NewSocket(zmq.REP)
19 | 	defer responder.Close()
20 | 	responder.Bind("tcp://*:5555")
21 | 
22 | 	for {
23 | 		//  Wait for next request from client
24 | 		msg, _ := responder.Recv(0)
25 | 		fmt.Println("Received ", msg)
26 | 
27 | 		//  Do some 'work'
28 | 		time.Sleep(time.Second)
29 | 
30 | 		//  Send reply back to client
31 | 		reply := "World"
32 | 		responder.Send(reply, 0)
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mmiecho.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  MMI echo query example.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	"github.com/pebbe/zmq4/examples/mdapi"
 9 | 
10 | 	"fmt"
11 | 	"os"
12 | 
13 | )
14 | 
15 | func main() {
16 | 	var verbose bool
17 | 	if len(os.Args) > 1 && os.Args[1] == "-v" {
18 | 		verbose = true
19 | 	}
20 | 	session, _ := mdapi.NewMdcli("tcp://localhost:5555", verbose)
21 | 
22 | 	//  This is the service we want to look up
23 | 	request := "echo"
24 | 
25 | 	//  This is the service we send our request to
26 | 	reply, err := session.Send("mmi.service", request)
27 | 
28 | 	if err == nil {
29 | 		fmt.Println("Lookup echo service:", reply[0])
30 | 	} else {
31 | 		fmt.Println("E: no response from broker, make sure it's running")
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/protobuf/prototweet.proto:
--------------------------------------------------------------------------------
 1 | message Tweet {
 2 |     message User {
 3 |         optional int64 id = 1;
 4 |         optional string name = 2;
 5 |     }
 6 | 
 7 | 	message Image {
 8 | 		optional string source = 1 [default = "TWITTER"];
 9 | 		optional string url = 2;
10 | 	}
11 | 
12 | 	message Url {
13 | 		optional string display = 1;
14 | 		optional string actual = 2;
15 | 	}
16 | 
17 |     message Coordinate {
18 |         optional double latitude = 1;
19 |         optional double longitude = 2;
20 |     }
21 | 
22 |     optional int64 id = 1;
23 |     optional User user = 2;
24 |     optional string text = 3;
25 |     optional Coordinate coordinates = 4;
26 |     repeated string hashtags = 5;
27 |     repeated Image pictures = 6;
28 |     repeated Url urls = 7;
29 |     repeated User mentions = 8;
30 | }
31 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/rrworker.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Hello World worker.
 3 | //  Connects REP socket to tcp://*:5560
 4 | //  Expects "Hello" from client, replies with "World"
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"time"
14 | )
15 | 
16 | func main() {
17 | 	//  Socket to talk to clients
18 | 	responder, _ := zmq.NewSocket(zmq.REP)
19 | 	defer responder.Close()
20 | 	responder.Connect("tcp://localhost:5560")
21 | 
22 | 	for {
23 | 		//  Wait for next request from client
24 | 		request, _ := responder.Recv(0)
25 | 		fmt.Printf("Received request: [%s]\n", request)
26 | 
27 | 		//  Do some 'work'
28 | 		time.Sleep(time.Second)
29 | 
30 | 		//  Send reply back to client
31 | 		responder.Send("World", 0)
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mdapi/const.go:
--------------------------------------------------------------------------------
 1 | // Majordomo Protocol Client and Worker API.
 2 | // Implements the MDP/Worker spec at http://rfc.zeromq.org/spec:7.
 3 | package mdapi
 4 | 
 5 | const (
 6 | 	//  This is the version of MDP/Client we implement
 7 | 	MDPC_CLIENT = "MDPC01"
 8 | 
 9 | 	//  This is the version of MDP/Worker we implement
10 | 	MDPW_WORKER = "MDPW01"
11 | )
12 | 
13 | const (
14 | 	//  MDP/Server commands, as strings
15 | 	MDPW_READY = string(iota + 1)
16 | 	MDPW_REQUEST
17 | 	MDPW_REPLY
18 | 	MDPW_HEARTBEAT
19 | 	MDPW_DISCONNECT
20 | )
21 | 
22 | var (
23 | 	MDPS_COMMANDS = map[string]string{
24 | 		MDPW_READY:      "READY",
25 | 		MDPW_REQUEST:    "REQUEST",
26 | 		MDPW_REPLY:      "REPLY",
27 | 		MDPW_HEARTBEAT:  "HEARTBEAT",
28 | 		MDPW_DISCONNECT: "DISCONNECT",
29 | 	}
30 | )
31 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/hwclient.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Hello World client.
 3 | //  Connects REQ socket to tcp://localhost:5555
 4 | //  Sends "Hello" to server, expects "World" back
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | )
14 | 
15 | func main() {
16 | 	//  Socket to talk to server
17 | 	fmt.Println("Connecting to hello world server...")
18 | 	requester, _ := zmq.NewSocket(zmq.REQ)
19 | 	defer requester.Close()
20 | 	requester.Connect("tcp://localhost:5555")
21 | 
22 | 	for request_nbr := 0; request_nbr != 10; request_nbr++ {
23 | 		// send hello
24 | 		msg := fmt.Sprintf("Hello %d", request_nbr)
25 | 		fmt.Println("Sending ", msg)
26 | 		requester.Send(msg, 0)
27 | 
28 | 		// Wait for reply:
29 | 		reply, _ := requester.Recv(0)
30 | 		fmt.Println("Received ", reply)
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/website/www/src/js/Overlay.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="lib/d3.d.ts"/>
 2 | /// <reference path="Tweet.ts"/>
 3 | /// <reference path="Map.ts"/>
 4 | /// <reference path="Feed.ts"/>
 5 | 
 6 | class Overlay {
 7 | 	private _active: boolean;
 8 | 	private _name: string
 9 | 
10 | 	constructor(private _displayName: string, public map: TweetMap) {
11 | 		this._name = this._displayName.toLowerCase().replace(' ', '');
12 | 		this._active = false;
13 | 	}
14 | 
15 | 	get name(): string {
16 | 		return this._name;
17 | 	}
18 | 
19 | 	get displayName(): string {
20 | 		return this._displayName;
21 | 	}
22 | 
23 | 	get active(): boolean {
24 | 		return this._active;
25 | 	}
26 | 
27 | 	activate(): void {
28 | 		if (!this._active) {
29 | 			this._active = true;
30 | 		}
31 | 	}
32 | 
33 | 	deactivate(): void {
34 | 		if (this._active) {
35 | 			this._active = false;
36 | 		}
37 | 	}
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/msgqueue.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Simple message queuing broker.
 3 | //  Same as request-reply broker but using QUEUE device
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"log"
12 | )
13 | 
14 | func main() {
15 | 	var err error
16 | 
17 | 	//  Socket facing clients
18 | 	frontend, _ := zmq.NewSocket(zmq.ROUTER)
19 | 	defer frontend.Close()
20 | 	err = frontend.Bind("tcp://*:5559")
21 | 	if err != nil {
22 | 		log.Fatalln("Binding frontend:", err)
23 | 	}
24 | 
25 | 	//  Socket facing services
26 | 	backend, _ := zmq.NewSocket(zmq.DEALER)
27 | 	defer backend.Close()
28 | 	err = backend.Bind("tcp://*:5560")
29 | 	if err != nil {
30 | 		log.Fatalln("Binding backend:", err)
31 | 	}
32 | 
33 | 	//  Start the proxy
34 | 	err = zmq.Proxy(frontend, backend, nil)
35 | 	log.Fatalln("Proxy interrupted:", err)
36 | }
37 | 


--------------------------------------------------------------------------------
/lib/Godeps/Godeps.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"ImportPath": "github.com/cdn-madness/tweetmap/lib",
 3 | 	"GoVersion": "go1.4.1",
 4 | 	"Deps": [
 5 | 		{
 6 | 			"ImportPath": "github.com/darkhelmet/twitterstream",
 7 | 			"Rev": "93b4246466e083b05852d77e0e747994881c2a91"
 8 | 		},
 9 | 		{
10 | 			"ImportPath": "github.com/garyburd/go-oauth/oauth",
11 | 			"Rev": "3569e4f99821388ee0a971edd55e1a76cf761407"
12 | 		},
13 | 		{
14 | 			"ImportPath": "github.com/golang/protobuf/proto",
15 | 			"Rev": "60976d353effd937b53a171e7493148a9969e39a"
16 | 		},
17 | 		{
18 | 			"ImportPath": "github.com/lib/pq",
19 | 			"Rev": "dc911180b321e9b7e08aa94f20939ef0109b9b24"
20 | 		},
21 | 		{
22 | 			"ImportPath": "github.com/pebbe/zmq4",
23 | 			"Rev": "b82b778e175510c98b2515834108ee8ad0c88819"
24 | 		},
25 | 		{
26 | 			"ImportPath": "github.com/stretchr/testify/assert",
27 | 			"Rev": "ae37dedcaae6fce497569786a8694aa3daa97abf"
28 | 		}
29 | 	]
30 | }
31 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/flserver2.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Freelance server - Model 2.
 3 | //  Does some work, replies OK, with message sequencing
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"os"
13 | )
14 | 
15 | func main() {
16 | 	if len(os.Args) < 2 {
17 | 		fmt.Printf("I: syntax: %s <endpoint>\n", os.Args[0])
18 | 		return
19 | 	}
20 | 	server, _ := zmq.NewSocket(zmq.REP)
21 | 	server.Bind(os.Args[1])
22 | 
23 | 	fmt.Println("I: service is ready at", os.Args[1])
24 | 	for {
25 | 		request, err := server.RecvMessage(0)
26 | 		if err != nil {
27 | 			break //  Interrupted
28 | 		}
29 | 		//  Fail nastily if run against wrong client
30 | 		if len(request) != 2 {
31 | 			panic("len(request) != 2")
32 | 		}
33 | 
34 | 		identity := request[0]
35 | 
36 | 		server.SendMessage(identity, "OK")
37 | 	}
38 | 	fmt.Println("W: interrupted")
39 | }
40 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mdclient2.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Majordomo Protocol client example - asynchronous.
 3 | //  Uses the mdcli API to hide all MDP aspects
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	"github.com/pebbe/zmq4/examples/mdapi"
10 | 
11 | 	"fmt"
12 | 	"log"
13 | 	"os"
14 | )
15 | 
16 | func main() {
17 | 	var verbose bool
18 | 	if len(os.Args) > 1 && os.Args[1] == "-v" {
19 | 		verbose = true
20 | 	}
21 | 	session, _ := mdapi.NewMdcli2("tcp://localhost:5555", verbose)
22 | 
23 | 	var count int
24 | 	for count = 0; count < 100000; count++ {
25 | 		err := session.Send("echo", "Hello world")
26 | 		if err != nil {
27 | 			log.Println("Send:", err)
28 | 			break
29 | 		}
30 | 	}
31 | 	for count = 0; count < 100000; count++ {
32 | 		_, err := session.Recv()
33 | 		if err != nil {
34 | 			log.Println("Recv:", err)
35 | 			break
36 | 		}
37 | 	}
38 | 	fmt.Printf("%d replies received\n", count)
39 | }
40 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/pathosub.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Pathological subscriber
 3 | //  Subscribes to one random topic and prints received messages
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"os"
14 | 	"time"
15 | )
16 | 
17 | func main() {
18 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
19 | 	if len(os.Args) == 2 {
20 | 		subscriber.Connect(os.Args[1])
21 | 	} else {
22 | 		subscriber.Connect("tcp://localhost:5556")
23 | 	}
24 | 
25 | 	rand.Seed(time.Now().UnixNano())
26 | 	subscription := fmt.Sprintf("%03d", rand.Intn(1000))
27 | 	subscriber.SetSubscribe(subscription)
28 | 
29 | 	for {
30 | 		msg, err := subscriber.RecvMessage(0)
31 | 		if err != nil {
32 | 			break
33 | 		}
34 | 		topic := msg[0]
35 | 		data := msg[1]
36 | 		if topic != subscription {
37 | 			panic("topic != subscription")
38 | 		}
39 | 		fmt.Println(data)
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/tasksink.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Task sink.
 3 | //  Binds PULL socket to tcp://localhost:5558
 4 | //  Collects results from workers via that socket
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"time"
14 | )
15 | 
16 | func main() {
17 | 	//  Prepare our socket
18 | 	receiver, _ := zmq.NewSocket(zmq.PULL)
19 | 	defer receiver.Close()
20 | 	receiver.Bind("tcp://*:5558")
21 | 
22 | 	//  Wait for start of batch
23 | 	receiver.Recv(0)
24 | 
25 | 	//  Start our clock now
26 | 	start_time := time.Now()
27 | 
28 | 	//  Process 100 confirmations
29 | 	for task_nbr := 0; task_nbr < 100; task_nbr++ {
30 | 		receiver.Recv(0)
31 | 		if task_nbr%10 == 0 {
32 | 			fmt.Print(":")
33 | 		} else {
34 | 			fmt.Print(".")
35 | 		}
36 | 	}
37 | 
38 | 	//  Calculate and report duration of batch
39 | 	fmt.Println("\nTotal elapsed time:", time.Since(start_time))
40 | }
41 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/flclient3.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Freelance client - Model 3.
 3 | //  Uses flcliapi class to encapsulate Freelance pattern
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	"github.com/pebbe/zmq4/examples/flcliapi"
10 | 
11 | 	"fmt"
12 | 	"time"
13 | )
14 | 
15 | func main() {
16 | 	//  Create new freelance client object
17 | 	client := flcliapi.New()
18 | 
19 | 	//  Connect to several endpoints
20 | 	client.Connect("tcp://localhost:5555")
21 | 	client.Connect("tcp://localhost:5556")
22 | 	client.Connect("tcp://localhost:5557")
23 | 
24 | 	//  Send a bunch of name resolution 'requests', measure time
25 | 	start := time.Now()
26 | 	req := []string{"random name"}
27 | 	for requests := 1000; requests > 0; requests-- {
28 | 		_, err := client.Request(req)
29 | 		if err != nil {
30 | 			fmt.Println("E: name service not available, aborting")
31 | 			break
32 | 		}
33 | 	}
34 | 	fmt.Println("Average round trip cost:", time.Now().Sub(start)/1000)
35 | }
36 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/certs/postgresql.key:
--------------------------------------------------------------------------------
 1 | -----BEGIN RSA PRIVATE KEY-----
 2 | MIICWwIBAAKBgQDjjAaacFRR0TQ0gznNolkPBe2N2A400JL0CU3ujHhVSST4POA0
 3 | WAKy55RYwejlu9Gv9lTBQLGQcHkNNVScjxbpwvCS5mRJOMF2+EdmxFtKtqlDzsi+
 4 | bE0rlJc8VbzR0G63U66JXEtrhkC+wa4eZM6crocKaeXIIRK+rh32Rd8WpwIDAQAB
 5 | AoGAM5dM6/kp9P700i8qjOgRPym96Zoh5nGfz/rIE5z/r36NBkdvIg8OVZfR96nH
 6 | b0b9TOMR5lsPp0sI9yivTWvX6qyvLJRWy2vvx17hXK9NxXUNTAm0PYZUTvCtcPeX
 7 | RnJpzQKNZQPkFzF0uXBc4CtPK2Vz0+FGvAelrhYAxnw1dIkCQQD+9qaW5QhXjsjb
 8 | Nl85CmXgxPmGROcgLQCO+omfrjf9UXrituU9Dz6auym5lDGEdMFnkzfr+wpasEy9
 9 | mf5ZZOhDAkEA5HjXfVGaCtpydOt6hDon/uZsyssCK2lQ7NSuE3vP+sUsYMzIpEoy
10 | t3VWXqKbo+g9KNDTP4WEliqp1aiSIylzzQJANPeqzihQnlgEdD4MdD4rwhFJwVIp
11 | Le8Lcais1KaN7StzOwxB/XhgSibd2TbnPpw+3bSg5n5lvUdo+e62/31OHwJAU1jS
12 | I+F09KikQIr28u3UUWT2IzTT4cpVv1AHAQyV3sG3YsjSGT0IK20eyP9BEBZU2WL0
13 | 7aNjrvR5aHxKc5FXsQJABsFtyGpgI5X4xufkJZVZ+Mklz2n7iXa+XPatMAHFxAtb
14 | EEMt60rngwMjXAzBSC6OYuYogRRAY3UCacNC5VhLYQ==
15 | -----END RSA PRIVATE KEY-----
16 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonesrv1.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone server Model One
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/kvsimple"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"time"
14 | )
15 | 
16 | func main() {
17 | 	//  Prepare our context and publisher socket
18 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
19 | 	publisher.Bind("tcp://*:5556")
20 | 	time.Sleep(200 * time.Millisecond)
21 | 
22 | 	kvmap := make(map[string]*kvsimple.Kvmsg)
23 | 	rand.Seed(time.Now().UnixNano())
24 | 
25 | 	sequence := int64(1)
26 | 	for ; true; sequence++ {
27 | 		//  Distribute as key-value message
28 | 		kvmsg := kvsimple.NewKvmsg(sequence)
29 | 		kvmsg.SetKey(fmt.Sprint(rand.Intn(10000)))
30 | 		kvmsg.SetBody(fmt.Sprint(rand.Intn(1000000)))
31 | 		err := kvmsg.Send(publisher)
32 | 		kvmsg.Store(kvmap)
33 | 		if err != nil {
34 | 			break
35 | 		}
36 | 	}
37 | 	fmt.Printf("Interrupted\n%d messages out\n", sequence)
38 | }
39 | 


--------------------------------------------------------------------------------
/website/www/src/js/API.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="lib/jquery.d.ts"/>
 2 | /// <reference path="lib/knockout.d.ts"/>
 3 | 
 4 | class API {
 5 | 	constructor(private _baseURL: string) {}
 6 | 
 7 | 	getOnlineCount(callback: (count: number) => void): void {
 8 | 		$.getJSON(this._baseURL + 'ws/info', (data: any) => { callback(data.clients); });
 9 | 	}
10 | 
11 | 	getJSON(name: string, callback: (json: any) => void): void {
12 | 		$.getJSON(this._baseURL + 'assets/' + name + '.json', function(data: any, status: any): void {
13 | 			if (status !== 'success') {
14 | 				console.log('Could not load ' + name + '.json');
15 | 			} else {
16 | 				callback(data);
17 | 			}
18 | 		});
19 | 	}
20 | 
21 | 	getTweetData(endpoint: string, callback: (json: any) => void): void {
22 | 		$.getJSON(this._baseURL + endpoint, function(data: any, status: any): void {
23 | 			if (status !== 'success') {
24 | 				console.log('Could not load ' + name + '.json');
25 | 			} else {
26 | 				callback(data);
27 | 			}
28 | 		});
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/wuserver.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Weather update server.
 3 | //  Binds PUB socket to tcp://*:5556
 4 | //  Publishes random weather updates
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"math/rand"
14 | 	"time"
15 | )
16 | 
17 | func main() {
18 | 
19 | 	//  Prepare our publisher
20 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
21 | 	defer publisher.Close()
22 | 	publisher.Bind("tcp://*:5556")
23 | 	publisher.Bind("ipc://weather.ipc")
24 | 
25 | 	//  Initialize random number generator
26 | 	rand.Seed(time.Now().UnixNano())
27 | 
28 | 	// loop for a while aparently
29 | 	for {
30 | 
31 | 		//  Get values that will fool the boss
32 | 		zipcode := rand.Intn(100000)
33 | 		temperature := rand.Intn(215) - 80
34 | 		relhumidity := rand.Intn(50) + 10
35 | 
36 | 		//  Send message to all subscribers
37 | 		msg := fmt.Sprintf("%05d %d %d", zipcode, temperature, relhumidity)
38 | 		publisher.Send(msg, 0)
39 | 	}
40 | }
41 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonecli6.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone client Model Six
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	"github.com/pebbe/zmq4/examples/clone"
 9 | 
10 | 	"fmt"
11 | 	"log"
12 | 	"math/rand"
13 | 	"time"
14 | )
15 | 
16 | const (
17 | 	SUBTREE = "/client/"
18 | )
19 | 
20 | func main() {
21 | 	//  Create distributed hash instance
22 | 	clone := clone.New()
23 | 
24 | 	//  Specify configuration
25 | 	clone.Subtree(SUBTREE)
26 | 	clone.Connect("tcp://localhost", "5556")
27 | 	clone.Connect("tcp://localhost", "5566")
28 | 
29 | 	//  Set random tuples into the distributed hash
30 | 	for {
31 | 		//  Set random value, check it was stored
32 | 		key := fmt.Sprintf("%s%d", SUBTREE, rand.Intn(10000))
33 | 		value := fmt.Sprint(rand.Intn(1000000))
34 | 		clone.Set(key, value, rand.Intn(30))
35 | 		v, _ := clone.Get(key)
36 | 		if v != value {
37 | 			log.Fatalf("Set: %v - Get: %v - Equal: %v\n", value, v, value == v)
38 | 		}
39 | 		time.Sleep(time.Second)
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/user_windows.go:
--------------------------------------------------------------------------------
 1 | // Package pq is a pure Go Postgres driver for the database/sql package.
 2 | package pq
 3 | 
 4 | import (
 5 | 	"path/filepath"
 6 | 	"syscall"
 7 | )
 8 | 
 9 | // Perform Windows user name lookup identically to libpq.
10 | //
11 | // The PostgreSQL code makes use of the legacy Win32 function
12 | // GetUserName, and that function has not been imported into stock Go.
13 | // GetUserNameEx is available though, the difference being that a
14 | // wider range of names are available.  To get the output to be the
15 | // same as GetUserName, only the base (or last) component of the
16 | // result is returned.
17 | func userCurrent() (string, error) {
18 | 	pw_name := make([]uint16, 128)
19 | 	pwname_size := uint32(len(pw_name)) - 1
20 | 	err := syscall.GetUserNameEx(syscall.NameSamCompatible, &pw_name[0], &pwname_size)
21 | 	if err != nil {
22 | 		return "", err
23 | 	}
24 | 	s := syscall.UTF16ToString(pw_name)
25 | 	u := filepath.Base(s)
26 | 	return u, nil
27 | }
28 | 


--------------------------------------------------------------------------------
/website/www/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "tweetmap-website",
 3 |   "version": "0.0.1",
 4 |   "description": "Website for the Ottawa tweet mapper",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "repository": {
10 |     "type": "git",
11 |     "url": "github.com/cdn-madness/tweetmap"
12 |   },
13 |   "author": "Alex Urquhart",
14 |   "license": "MIT",
15 |   "bugs": {
16 |     "url": "https://github.com/cdn-madness/tweetmap/issues"
17 |   },
18 |   "devDependencies": {
19 |     "grunt": "~0.4.5",
20 |     "tslint": "~2.1.0",
21 |     "grunt-tslint": "~2.0.0",
22 |     "typescript": "~1.4.1",
23 |     "grunt-typescript": "~0.6.1",
24 |     "grunt-contrib-copy": "~0.7.0",
25 |     "grunt-contrib-watch": "~0.6.1",
26 |     "grunt-contrib-less": "~1.0.0",
27 |     "grunt-contrib-htmlmin": "~0.4.0",
28 |     "bower": "~1.3.12",
29 |     "grunt-contrib-clean": "~0.6.0",
30 |     "grunt-inject": "~0.1.1",
31 |     "grunt-contrib-connect": "^0.9.0"
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/website/www/src/css/bootstrap.less:
--------------------------------------------------------------------------------
 1 | @import "../bower_components/bootstrap/less/bootstrap.less";
 2 | 
 3 | @brand-primary: #4970BF;
 4 | @body-bg: #4F5463;
 5 | @text-muted: #C3D0F7;
 6 | @text-color: lighten(@text-muted, 10%);
 7 | @link-color: #FFF;
 8 | //@border-radius-base: 0px;
 9 | 
10 | @font-family-sans-serif: 'Roboto', Helvetica, sans-serif;
11 | @font-family-base: @font-family-sans-serif;
12 | 
13 | @navbar-inverse-bg: #343D59;
14 | @navbar-inverse-link-color: @text-muted;
15 | @navbar-inverse-link-hover-color: lighten(@text-muted, 10%);
16 | @navbar-inverse-link-active-bg: lighten(@navbar-inverse-bg, 6.5%);
17 | @navbar-inverse-link-active-color: @navbar-inverse-link-color;
18 | 
19 | @dropdown-bg: @navbar-inverse-link-active-bg;
20 | @dropdown-link-color: @navbar-inverse-link-color;
21 | 
22 | @list-group-bg: #E8EEFF;
23 | 
24 | @nav-tabs-border-color: lighten(@body-bg, 10%);
25 | @nav-tabs-active-link-hover-bg: lighten(@body-bg, 10%);
26 | @nav-tabs-active-link-hover-border-color: lighten(@body-bg, 15%);
27 | 
28 | @table-bg-hover: lighten(@body-bg, 10%);
29 | 
30 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/lpserver.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Lazy Pirate server.
 3 | //  Binds REQ socket to tcp://*:5555
 4 | //  Like hwserver except:
 5 | //   - echoes request as-is
 6 | //   - randomly runs slowly, or exits to simulate a crash.
 7 | //
 8 | 
 9 | package main
10 | 
11 | import (
12 | 	zmq "github.com/pebbe/zmq4"
13 | 
14 | 	"fmt"
15 | 	"math/rand"
16 | 	"time"
17 | )
18 | 
19 | func main() {
20 | 	rand.Seed(time.Now().UnixNano())
21 | 
22 | 	server, _ := zmq.NewSocket(zmq.REP)
23 | 	defer server.Close()
24 | 	server.Bind("tcp://*:5555")
25 | 
26 | 	for cycles := 0; true; {
27 | 		request, _ := server.RecvMessage(0)
28 | 		cycles++
29 | 
30 | 		//  Simulate various problems, after a few cycles
31 | 		if cycles > 3 && rand.Intn(3) == 0 {
32 | 			fmt.Println("I: simulating a crash")
33 | 			break
34 | 		} else if cycles > 3 && rand.Intn(3) == 0 {
35 | 			fmt.Println("I: simulating CPU overload")
36 | 			time.Sleep(2 * time.Second)
37 | 		}
38 | 		fmt.Printf("I: normal request (%s)\n", request)
39 | 		time.Sleep(time.Second) //  Do some heavy work
40 | 		server.SendMessage(request)
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/taskwork.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Task worker.
 3 | //  Connects PULL socket to tcp://localhost:5557
 4 | //  Collects workloads from ventilator via that socket
 5 | //  Connects PUSH socket to tcp://localhost:5558
 6 | //  Sends results to sink via that socket
 7 | //
 8 | 
 9 | package main
10 | 
11 | import (
12 | 	zmq "github.com/pebbe/zmq4"
13 | 
14 | 	"fmt"
15 | 	"strconv"
16 | 	"time"
17 | )
18 | 
19 | func main() {
20 | 	//  Socket to receive messages on
21 | 	receiver, _ := zmq.NewSocket(zmq.PULL)
22 | 	defer receiver.Close()
23 | 	receiver.Connect("tcp://localhost:5557")
24 | 
25 | 	//  Socket to send messages to
26 | 	sender, _ := zmq.NewSocket(zmq.PUSH)
27 | 	defer sender.Close()
28 | 	sender.Connect("tcp://localhost:5558")
29 | 
30 | 	//  Process tasks forever
31 | 	for {
32 | 		s, _ := receiver.Recv(0)
33 | 
34 | 		//  Simple progress indicator for the viewer
35 | 		fmt.Print(s + ".")
36 | 
37 | 		//  Do the work
38 | 		msec, _ := strconv.Atoi(s)
39 | 		time.Sleep(time.Duration(msec) * time.Millisecond)
40 | 
41 | 		//  Send results to sink
42 | 		sender.Send("", 0)
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/pathopub.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Pathological publisher
 3 | //  Sends out 1,000 topics and then one random update per second
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"os"
14 | 	"time"
15 | )
16 | 
17 | func main() {
18 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
19 | 	if len(os.Args) == 2 {
20 | 		publisher.Connect(os.Args[1])
21 | 	} else {
22 | 		publisher.Bind("tcp://*:5556")
23 | 	}
24 | 
25 | 	//  Ensure subscriber connection has time to complete
26 | 	time.Sleep(time.Second)
27 | 
28 | 	//  Send out all 1,000 topic messages
29 | 	for topic_nbr := 0; topic_nbr < 1000; topic_nbr++ {
30 | 		_, err := publisher.SendMessage(fmt.Sprintf("%03d", topic_nbr), "Save Roger")
31 | 		if err != nil {
32 | 			fmt.Println(err)
33 | 		}
34 | 	}
35 | 	//  Send one random update per second
36 | 	rand.Seed(time.Now().UnixNano())
37 | 	for {
38 | 		time.Sleep(time.Second)
39 | 		_, err := publisher.SendMessage(fmt.Sprintf("%03d", rand.Intn(1000)), "Off with his head!")
40 | 		if err != nil {
41 | 			fmt.Println(err)
42 | 		}
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015, Alex Urquhart
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/LICENSE.md:
--------------------------------------------------------------------------------
1 | Copyright (c) 2011-2013, 'pq' Contributors
2 | Portions Copyright (C) 2011 Blake Mizerany
3 | 
4 | 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:
5 | 
6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
7 | 
8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
9 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/tasksink2.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Task sink - design 2.
 3 | //  Adds pub-sub flow to send kill signal to workers
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"time"
13 | )
14 | 
15 | func main() {
16 | 	//  Socket to receive messages on
17 | 	receiver, _ := zmq.NewSocket(zmq.PULL)
18 | 	defer receiver.Close()
19 | 	receiver.Bind("tcp://*:5558")
20 | 
21 | 	//  Socket for worker control
22 | 	controller, _ := zmq.NewSocket(zmq.PUB)
23 | 	defer controller.Close()
24 | 	controller.Bind("tcp://*:5559")
25 | 
26 | 	//  Wait for start of batch
27 | 	receiver.Recv(0)
28 | 
29 | 	//  Start our clock now
30 | 	start_time := time.Now()
31 | 
32 | 	//  Process 100 confirmations
33 | 	for task_nbr := 0; task_nbr < 100; task_nbr++ {
34 | 		receiver.Recv(0)
35 | 		if task_nbr%10 == 0 {
36 | 			fmt.Print(":")
37 | 		} else {
38 | 			fmt.Print(".")
39 | 		}
40 | 	}
41 | 	fmt.Println("\nTotal elapsed time:", time.Since(start_time))
42 | 
43 | 	//  Send kill signal to workers
44 | 	controller.Send("KILL", 0)
45 | 
46 | 	//  Finished
47 | 	time.Sleep(time.Second) //  Give 0MQ time to deliver
48 | }
49 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/place.go:
--------------------------------------------------------------------------------
 1 | package twitterstream
 2 | 
 3 | type Place struct {
 4 |     // Contains a hash of variant information about the place.
 5 |     Attributes map[string]interface{} `json:"attributes"`
 6 | 
 7 |     // A bounding box of coordinates which encloses this place.
 8 |     BoundingBox Box `json:"bounding_box"`
 9 | 
10 |     // Name of the country containing this place.
11 |     Country string `json:"country"`
12 | 
13 |     // Shortened country code representing the country containing this place.
14 |     CountryCode string `json:"country_code"`
15 | 
16 |     // Full human-readable representation of the place's name.
17 |     FullName string `json:"full_name"`
18 | 
19 |     // ID representing this place. Note that this is represented as a string, not an integer.
20 |     Id  string `json:"id"`
21 | 
22 |     // Short human-readable representation of the place's name.
23 |     Name string `json:"name"`
24 | 
25 |     // The type of location represented by this place.
26 |     Type string `json:"place_type"`
27 | 
28 |     // URL representing the location of additional place metadata for this place.
29 |     Url string `json:"url"`
30 | }
31 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/syncsub.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Synchronized subscriber
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | 	"log"
12 | 	"time"
13 | )
14 | 
15 | func main() {
16 | 
17 | 	//  First, connect our subscriber socket
18 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
19 | 	defer subscriber.Close()
20 | 	subscriber.Connect("tcp://localhost:5561")
21 | 	subscriber.SetSubscribe("")
22 | 
23 | 	//  0MQ is so fast, we need to wait a while...
24 | 	time.Sleep(time.Second)
25 | 
26 | 	//  Second, synchronize with publisher
27 | 	syncclient, _ := zmq.NewSocket(zmq.REQ)
28 | 	defer syncclient.Close()
29 | 	syncclient.Connect("tcp://localhost:5562")
30 | 
31 | 	//  - send a synchronization request
32 | 	syncclient.Send("", 0)
33 | 
34 | 	//  - wait for synchronization reply
35 | 	syncclient.Recv(0)
36 | 
37 | 	//  Third, get our updates and report how many we got
38 | 	update_nbr := 0
39 | 	for {
40 | 		msg, e := subscriber.Recv(0)
41 | 		if e != nil {
42 | 			log.Println(e)
43 | 			break
44 | 		}
45 | 		if msg == "END" {
46 | 			break
47 | 		}
48 | 		update_nbr++
49 | 	}
50 | 	fmt.Printf("Received %d updates\n", update_nbr)
51 | }
52 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples_security/grasslands.go:
--------------------------------------------------------------------------------
 1 | //  The Grasslands Pattern
 2 | //
 3 | //  The Classic ZeroMQ model, plain text with no protection at all.
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | 	"log"
12 | 	"runtime"
13 | )
14 | 
15 | func main() {
16 | 
17 | 	//  Create and bind server socket
18 | 	server, err := zmq.NewSocket(zmq.PUSH)
19 | 	checkErr(err)
20 | 	checkErr(server.Bind("tcp://*:9000"))
21 | 
22 | 	//  Create and connect client socket
23 | 	client, err := zmq.NewSocket(zmq.PULL)
24 | 	checkErr(err)
25 | 	checkErr(client.Connect("tcp://127.0.0.1:9000"))
26 | 
27 | 	//  Send a single message from server to client
28 | 	_, err = server.Send("Hello", 0)
29 | 	checkErr(err)
30 | 	message, err := client.Recv(0)
31 | 	checkErr(err)
32 | 	if message != "Hello" {
33 | 		log.Fatalln(message, "!= Hello")
34 | 	}
35 | 
36 | 	fmt.Println("Grasslands test OK")
37 | }
38 | 
39 | func checkErr(err error) {
40 | 	if err != nil {
41 | 		log.SetFlags(0)
42 | 		_, filename, lineno, ok := runtime.Caller(1)
43 | 		if ok {
44 | 			log.Fatalf("%v:%v: %v", filename, lineno, err)
45 | 		} else {
46 | 			log.Fatalln(err)
47 | 		}
48 | 	}
49 | }
50 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mspoller.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Reading from multiple sockets.
 3 | //  This version uses zmq.Poll()
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | )
13 | 
14 | func main() {
15 | 
16 | 	//  Connect to task ventilator
17 | 	receiver, _ := zmq.NewSocket(zmq.PULL)
18 | 	defer receiver.Close()
19 | 	receiver.Connect("tcp://localhost:5557")
20 | 
21 | 	//  Connect to weather server
22 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
23 | 	defer subscriber.Close()
24 | 	subscriber.Connect("tcp://localhost:5556")
25 | 	subscriber.SetSubscribe("10001 ")
26 | 
27 | 	//  Initialize poll set
28 | 	poller := zmq.NewPoller()
29 | 	poller.Add(receiver, zmq.POLLIN)
30 | 	poller.Add(subscriber, zmq.POLLIN)
31 | 	//  Process messages from both sockets
32 | 	for {
33 | 		sockets, _ := poller.Poll(-1)
34 | 		for _, socket := range sockets {
35 | 			switch s := socket.Socket; s {
36 | 			case receiver:
37 | 				task, _ := s.Recv(0)
38 | 				//  Process task
39 | 				fmt.Println("Got task:", task)
40 | 			case subscriber:
41 | 				update, _ := s.Recv(0)
42 | 				//  Process weather update
43 | 				fmt.Println("Got weather update:", update)
44 | 			}
45 | 		}
46 | 	}
47 | }
48 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/wuclient.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Weather update client.
 3 | //  Connects SUB socket to tcp://localhost:5556
 4 | //  Collects weather updates and finds avg temp in zipcode
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"os"
14 | 	"strconv"
15 | 	"strings"
16 | )
17 | 
18 | func main() {
19 | 	//  Socket to talk to server
20 | 	fmt.Println("Collecting updates from weather server...")
21 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
22 | 	defer subscriber.Close()
23 | 	subscriber.Connect("tcp://localhost:5556")
24 | 
25 | 	//  Subscribe to zipcode, default is NYC, 10001
26 | 	filter := "10001 "
27 | 	if len(os.Args) > 1 {
28 | 		filter = os.Args[1] + " "
29 | 	}
30 | 	subscriber.SetSubscribe(filter)
31 | 
32 | 	//  Process 100 updates
33 | 	total_temp := 0
34 | 	update_nbr := 0
35 | 	for update_nbr < 100 {
36 | 		msg, _ := subscriber.Recv(0)
37 | 
38 | 		if msgs := strings.Fields(msg); len(msgs) > 1 {
39 | 			if temperature, err := strconv.Atoi(msgs[1]); err == nil {
40 | 				total_temp += temperature
41 | 				update_nbr++
42 | 			}
43 | 		}
44 | 	}
45 | 	fmt.Printf("Average temperature for zipcode '%s' was %dF \n\n", strings.TrimSpace(filter), total_temp/update_nbr)
46 | }
47 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/rrbroker.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Simple request-reply broker.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | )
10 | 
11 | func main() {
12 | 	//  Prepare our sockets
13 | 	frontend, _ := zmq.NewSocket(zmq.ROUTER)
14 | 	defer frontend.Close()
15 | 	backend, _ := zmq.NewSocket(zmq.DEALER)
16 | 	defer backend.Close()
17 | 	frontend.Bind("tcp://*:5559")
18 | 	backend.Bind("tcp://*:5560")
19 | 
20 | 	//  Initialize poll set
21 | 	poller := zmq.NewPoller()
22 | 	poller.Add(frontend, zmq.POLLIN)
23 | 	poller.Add(backend, zmq.POLLIN)
24 | 
25 | 	//  Switch messages between sockets
26 | 	for {
27 | 		sockets, _ := poller.Poll(-1)
28 | 		for _, socket := range sockets {
29 | 			switch s := socket.Socket; s {
30 | 			case frontend:
31 | 				for {
32 | 					msg, _ := s.Recv(0)
33 | 					if more, _ := s.GetRcvmore(); more {
34 | 						backend.Send(msg, zmq.SNDMORE)
35 | 					} else {
36 | 						backend.Send(msg, 0)
37 | 						break
38 | 					}
39 | 				}
40 | 			case backend:
41 | 				for {
42 | 					msg, _ := s.Recv(0)
43 | 					if more, _ := s.GetRcvmore(); more {
44 | 						frontend.Send(msg, zmq.SNDMORE)
45 | 					} else {
46 | 						frontend.Send(msg, 0)
47 | 						break
48 | 					}
49 | 				}
50 | 			}
51 | 		}
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/bstarsrv2.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Binary Star server, using bstar reactor.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/bstar"
10 | 
11 | 	"fmt"
12 | 	"os"
13 | )
14 | 
15 | //  Echo service
16 | func echo(socket *zmq.Socket) (err error) {
17 | 	msg, err := socket.RecvMessage(0)
18 | 	if err != nil {
19 | 		return
20 | 	}
21 | 	_, err = socket.SendMessage(msg)
22 | 	return
23 | }
24 | 
25 | func main() {
26 | 	//  Arguments can be either of:
27 | 	//      -p  primary server, at tcp://localhost:5001
28 | 	//      -b  backup server, at tcp://localhost:5002
29 | 	var bst *bstar.Bstar
30 | 	if len(os.Args) == 2 && os.Args[1] == "-p" {
31 | 		fmt.Println("I: Primary active, waiting for backup (passive)")
32 | 		bst, _ = bstar.New(bstar.PRIMARY, "tcp://*:5003", "tcp://localhost:5004")
33 | 		bst.Voter("tcp://*:5001", zmq.ROUTER, echo)
34 | 	} else if len(os.Args) == 2 && os.Args[1] == "-b" {
35 | 		fmt.Println("I: Backup passive, waiting for primary (active)")
36 | 		bst, _ = bstar.New(bstar.BACKUP, "tcp://*:5004", "tcp://localhost:5003")
37 | 		bst.Voter("tcp://*:5002", zmq.ROUTER, echo)
38 | 	} else {
39 | 		fmt.Println("Usage: bstarsrvs { -p | -b }")
40 | 		return
41 | 	}
42 | 	bst.Start()
43 | }
44 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mtrelay.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Multithreaded relay.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | )
12 | 
13 | func step1() {
14 | 	//  Connect to step2 and tell it we're ready
15 | 	xmitter, _ := zmq.NewSocket(zmq.PAIR)
16 | 	defer xmitter.Close()
17 | 	xmitter.Connect("inproc://step2")
18 | 	fmt.Println("Step 1 ready, signaling step 2")
19 | 	xmitter.Send("READY", 0)
20 | }
21 | 
22 | func step2() {
23 | 	//  Bind inproc socket before starting step1
24 | 	receiver, _ := zmq.NewSocket(zmq.PAIR)
25 | 	defer receiver.Close()
26 | 	receiver.Bind("inproc://step2")
27 | 	go step1()
28 | 
29 | 	//  Wait for signal and pass it on
30 | 	receiver.Recv(0)
31 | 
32 | 	//  Connect to step3 and tell it we're ready
33 | 	xmitter, _ := zmq.NewSocket(zmq.PAIR)
34 | 	defer xmitter.Close()
35 | 	xmitter.Connect("inproc://step3")
36 | 	fmt.Println("Step 2 ready, signaling step 3")
37 | 	xmitter.Send("READY", 0)
38 | }
39 | 
40 | func main() {
41 | 
42 | 	//  Bind inproc socket before starting step2
43 | 	receiver, _ := zmq.NewSocket(zmq.PAIR)
44 | 	defer receiver.Close()
45 | 	receiver.Bind("inproc://step3")
46 | 	go step2()
47 | 
48 | 	//  Wait for signal
49 | 	receiver.Recv(0)
50 | 
51 | 	fmt.Println("Test successful!")
52 | }
53 | 


--------------------------------------------------------------------------------
/lib/feed_test.go:
--------------------------------------------------------------------------------
 1 | package tweetmap
 2 | 
 3 | import (
 4 | 	"github.com/darkhelmet/twitterstream"
 5 | 	"github.com/stretchr/testify/assert"
 6 | 	"log"
 7 | 	"os"
 8 | 	"testing"
 9 | 	"time"
10 | )
11 | 
12 | func TestListenToTwitter(t *testing.T) {
13 | 	// Get environment variables and construct API info
14 | 	apiCfg := TwitterAPIConfig{
15 | 		AccessSecret:   os.Getenv("TWITTER_ACCESS_SECRET"),
16 | 		AccessToken:    os.Getenv("TWITTER_ACCESS_TOKEN"),
17 | 		ConsumerSecret: os.Getenv("TWITTER_CONSUMER_SECRET"),
18 | 		ConsumerKey:    os.Getenv("TWITTER_CONSUMER_KEY"),
19 | 		SouthEast:      twitterstream.Point{0, 0},
20 | 		NorthWest:      twitterstream.Point{90, 180},
21 | 	}
22 | 
23 | 	filter := func(t *twitterstream.Tweet) bool {
24 | 		return true
25 | 	}
26 | 
27 | 	doneChan := make(chan bool)
28 | 	defer close(doneChan)
29 | 	tweetChan, errChan := ListenToTwitter(apiCfg, filter, doneChan)
30 | 
31 | L:
32 | 	for {
33 | 		select {
34 | 		case <-tweetChan:
35 | 			log.Println("Received tweet")
36 | 			break L
37 | 		case err := <-errChan:
38 | 			// Determine the error type
39 | 			if _, ok := err.(*ProtoTweetError); !ok {
40 | 				t.Log(err)
41 | 				assert.Fail(t, err.Error())
42 | 			}
43 | 		case <-time.After(time.Minute):
44 | 			assert.Fail(t, "No tweets received in past 60 seconds.")
45 | 		}
46 | 	}
47 | 
48 | }
49 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/conn_xact_test.go:
--------------------------------------------------------------------------------
 1 | // +build go1.1
 2 | 
 3 | package pq
 4 | 
 5 | import (
 6 | 	"testing"
 7 | )
 8 | 
 9 | func TestXactMultiStmt(t *testing.T) {
10 | 	// minified test case based on bug reports from
11 | 	// pico303@gmail.com and rangelspam@gmail.com
12 | 	t.Skip("Skipping failing test")
13 | 	db := openTestConn(t)
14 | 	defer db.Close()
15 | 
16 | 	tx, err := db.Begin()
17 | 	if err != nil {
18 | 		t.Fatal(err)
19 | 	}
20 | 	defer tx.Commit()
21 | 
22 | 	rows, err := tx.Query("select 1")
23 | 	if err != nil {
24 | 		t.Fatal(err)
25 | 	}
26 | 
27 | 	if rows.Next() {
28 | 		var val int32
29 | 		if err = rows.Scan(&val); err != nil {
30 | 			t.Fatal(err)
31 | 		}
32 | 	} else {
33 | 		t.Fatal("Expected at least one row in first query in xact")
34 | 	}
35 | 
36 | 	rows2, err := tx.Query("select 2")
37 | 	if err != nil {
38 | 		t.Fatal(err)
39 | 	}
40 | 
41 | 	if rows2.Next() {
42 | 		var val2 int32
43 | 		if err := rows2.Scan(&val2); err != nil {
44 | 			t.Fatal(err)
45 | 		}
46 | 	} else {
47 | 		t.Fatal("Expected at least one row in second query in xact")
48 | 	}
49 | 
50 | 	if err = rows.Err(); err != nil {
51 | 		t.Fatal(err)
52 | 	}
53 | 
54 | 	if err = rows2.Err(); err != nil {
55 | 		t.Fatal(err)
56 | 	}
57 | 
58 | 	if err = tx.Commit(); err != nil {
59 | 		t.Fatal(err)
60 | 	}
61 | }
62 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/mtserver.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Multithreaded Hello World server.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | 	"log"
12 | 	"time"
13 | )
14 | 
15 | func worker_routine() {
16 | 	//  Socket to talk to dispatcher
17 | 	receiver, _ := zmq.NewSocket(zmq.REP)
18 | 	defer receiver.Close()
19 | 	receiver.Connect("inproc://workers")
20 | 
21 | 	for {
22 | 		msg, e := receiver.Recv(0)
23 | 		if e != nil {
24 | 			break
25 | 		}
26 | 		fmt.Println("Received request: [" + msg + "]")
27 | 
28 | 		//  Do some 'work'
29 | 		time.Sleep(time.Second)
30 | 
31 | 		//  Send reply back to client
32 | 		receiver.Send("World", 0)
33 | 	}
34 | }
35 | 
36 | func main() {
37 | 	//  Socket to talk to clients
38 | 	clients, _ := zmq.NewSocket(zmq.ROUTER)
39 | 	defer clients.Close()
40 | 	clients.Bind("tcp://*:5555")
41 | 
42 | 	//  Socket to talk to workers
43 | 	workers, _ := zmq.NewSocket(zmq.DEALER)
44 | 	defer workers.Close()
45 | 	workers.Bind("inproc://workers")
46 | 
47 | 	//  Launch pool of worker goroutines
48 | 	for thread_nbr := 0; thread_nbr < 5; thread_nbr++ {
49 | 		go worker_routine()
50 | 	}
51 | 	//  Connect work threads to client threads via a queue proxy
52 | 	err := zmq.Proxy(clients, workers, nil)
53 | 	log.Fatalln("Proxy interrupted:", err)
54 | }
55 | 


--------------------------------------------------------------------------------
/website/www/src/js/Map.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="lib/leaflet.d.ts"/>
 2 | /// <reference path="lib/jquery.d.ts"/>
 3 | /// <reference path="Tweet.ts"/>
 4 | 
 5 | class TweetMap {
 6 | 	private _map: L.Map;
 7 | 
 8 | 	constructor(div: string = 'map') {
 9 | 		this._map = new L.Map(div).setView(new L.LatLng(45.41, -75.698), 12);
10 | 
11 | 		L.tileLayer('http://services.arcgisonline.com/arcgis/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}', {
12 | 		    maxZoom: 16
13 | 		}).addTo(this._map);
14 | 		L.tileLayer('http://services.arcgisonline.com/arcgis/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}', {
15 | 		    maxZoom: 16
16 | 		}).addTo(this._map);
17 | 	}
18 | 
19 | 	addTweet(tweet: Tweet): void {
20 | 		this._map.addLayer(tweet.marker);
21 | 	}
22 | 
23 | 	removeTweet(tweet: Tweet): void {
24 | 		this._map.removeLayer(tweet.marker);
25 | 	}
26 | 
27 | 	panTo(tweet: Tweet): void {
28 | 		this._map.panTo(tweet.marker.getLatLng());
29 | 		tweet.marker.openPopup();
30 | 	}
31 | 
32 | 	// Toggles the marker and shadow panes off -also closes any popup windows
33 | 	toggleMarkers(tweets: Tweet[]): void {
34 | 
35 | 		$.each(tweets, function(index: number, tweet: Tweet): void {
36 | 			tweet.marker.closePopup();
37 | 		});
38 | 
39 | 		$('.leaflet-marker-pane, .leaflet-shadow-pane').fadeToggle();
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/msreader.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Reading from multiple sockets.
 3 | //  This version uses a simple recv loop
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"time"
13 | )
14 | 
15 | func main() {
16 | 
17 | 	//  Connect to task ventilator
18 | 	receiver, _ := zmq.NewSocket(zmq.PULL)
19 | 	defer receiver.Close()
20 | 	receiver.Connect("tcp://localhost:5557")
21 | 
22 | 	//  Connect to weather server
23 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
24 | 	defer subscriber.Close()
25 | 	subscriber.Connect("tcp://localhost:5556")
26 | 	subscriber.SetSubscribe("10001 ")
27 | 
28 | 	//  Process messages from both sockets
29 | 	//  We prioritize traffic from the task ventilator
30 | 	for {
31 | 
32 | 		//  Process any waiting tasks
33 | 		for {
34 | 			task, err := receiver.Recv(zmq.DONTWAIT)
35 | 			if err != nil {
36 | 				break
37 | 			}
38 | 			//  process task
39 | 			fmt.Println("Got task:", task)
40 | 		}
41 | 
42 | 		//  Process any waiting weather updates
43 | 		for {
44 | 			udate, err := subscriber.Recv(zmq.DONTWAIT)
45 | 			if err != nil {
46 | 				break
47 | 			}
48 | 			//  process weather update
49 | 			fmt.Println("Got weather update:", udate)
50 | 		}
51 | 
52 | 		//  No activity, so sleep for 1 msec
53 | 		time.Sleep(time.Millisecond)
54 | 	}
55 | }
56 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | ## Contributing to pq
 2 | 
 3 | `pq` has a backlog of pull requests, but contributions are still very
 4 | much welcome. You can help with patch review, submitting bug reports,
 5 | or adding new functionality. There is no formal style guide, but
 6 | please conform to the style of existing code and general Go formatting
 7 | conventions when submitting patches.
 8 | 
 9 | ### Patch review
10 | 
11 | Help review existing open pull requests by commenting on the code or
12 | proposed functionality.
13 | 
14 | ### Bug reports
15 | 
16 | We appreciate any bug reports, but especially ones with self-contained
17 | (doesn't depend on code outside of pq), minimal (can't be simplified
18 | further) test cases. It's especially helpful if you can submit a pull
19 | request with just the failing test case (you'll probably want to
20 | pattern it after the tests in
21 | [conn_test.go](https://github.com/lib/pq/blob/master/conn_test.go).
22 | 
23 | ### New functionality
24 | 
25 | There are a number of pending patches for new functionality, so
26 | additional feature patches will take a while to merge. Still, patches
27 | are generally reviewed based on usefulness and complexity in addition
28 | to time-in-queue, so if you have a knockout idea, take a shot. Feel
29 | free to open an issue discussion your proposed patch beforehand.
30 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/kvsimple/kvsimple_test.go:
--------------------------------------------------------------------------------
 1 | package kvsimple
 2 | 
 3 | import (
 4 | 	zmq "github.com/pebbe/zmq4"
 5 | 
 6 | 	"os"
 7 | 	"testing"
 8 | )
 9 | 
10 | func TestKvmsg(t *testing.T) {
11 | 
12 | 	//  Prepare our context and sockets
13 | 	output, err := zmq.NewSocket(zmq.DEALER)
14 | 	if err != nil {
15 | 		t.Error(err)
16 | 	}
17 | 
18 | 	err = output.Bind("ipc://kvmsg_selftest.ipc")
19 | 	if err != nil {
20 | 		t.Error(err)
21 | 	}
22 | 
23 | 	input, err := zmq.NewSocket(zmq.DEALER)
24 | 	if err != nil {
25 | 		t.Error(err)
26 | 	}
27 | 
28 | 	err = input.Connect("ipc://kvmsg_selftest.ipc")
29 | 	if err != nil {
30 | 		t.Error(err)
31 | 	}
32 | 
33 | 	kvmap := make(map[string]*Kvmsg)
34 | 
35 | 	//  Test send and receive of simple message
36 | 	kvmsg := NewKvmsg(1)
37 | 	kvmsg.SetKey("key")
38 | 	kvmsg.SetBody("body")
39 | 	kvmsg.Dump()
40 | 	err = kvmsg.Send(output)
41 | 
42 | 	kvmsg.Store(kvmap)
43 | 	if err != nil {
44 | 		t.Error(err)
45 | 	}
46 | 
47 | 	kvmsg, err = RecvKvmsg(input)
48 | 	if err != nil {
49 | 		t.Error(err)
50 | 	}
51 | 	kvmsg.Dump()
52 | 	key, err := kvmsg.GetKey()
53 | 	if err != nil {
54 | 		t.Error(err)
55 | 	}
56 | 	if key != "key" {
57 | 		t.Error("Expected \"key\", got \"" + key + "\"")
58 | 	}
59 | 	kvmsg.Store(kvmap)
60 | 
61 | 	input.Close()
62 | 	output.Close()
63 | 	os.Remove("kvmsg_selftest.ipc")
64 | }
65 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/socketevent_test.go:
--------------------------------------------------------------------------------
 1 | package zmq4_test
 2 | 
 3 | import (
 4 | 	zmq "github.com/pebbe/zmq4"
 5 | 
 6 | 	"fmt"
 7 | 	"time"
 8 | )
 9 | 
10 | func rep_socket_monitor(addr string) {
11 | 	s, err := zmq.NewSocket(zmq.PAIR)
12 | 	if checkErr(err) {
13 | 		return
14 | 	}
15 | 	defer s.Close()
16 | 	err = s.Connect(addr)
17 | 	if checkErr(err) {
18 | 		return
19 | 	}
20 | 	for {
21 | 		a, b, _, err := s.RecvEvent(0)
22 | 		if checkErr(err) {
23 | 			break
24 | 		}
25 | 		fmt.Println(a, b)
26 | 		if a == zmq.EVENT_CLOSED {
27 | 			break
28 | 		}
29 | 	}
30 | }
31 | 
32 | func Example_socket_event() {
33 | 
34 | 	// REP socket
35 | 	rep, err := zmq.NewSocket(zmq.REP)
36 | 	if checkErr(err) {
37 | 		return
38 | 	}
39 | 
40 | 	// REP socket monitor, all events
41 | 	err = rep.Monitor("inproc://monitor.rep", zmq.EVENT_ALL)
42 | 	if checkErr(err) {
43 | 		rep.Close()
44 | 		return
45 | 	}
46 | 	go rep_socket_monitor("inproc://monitor.rep")
47 | 	time.Sleep(time.Second)
48 | 
49 | 	// Generate an event
50 | 	rep.Bind("tcp://*:9689")
51 | 	if checkErr(err) {
52 | 		rep.Close()
53 | 		return
54 | 	}
55 | 
56 | 	rep.Close()
57 | 
58 | 	// Allow some time for event detection
59 | 	time.Sleep(time.Second)
60 | 
61 | 	fmt.Println("Done")
62 | 	// Output:
63 | 	// EVENT_LISTENING tcp://0.0.0.0:9689
64 | 	// EVENT_CLOSED tcp://0.0.0.0:9689
65 | 	// Done
66 | }
67 | 


--------------------------------------------------------------------------------
/website/www/src/js/Feed.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="Tweet.ts"/>
 2 | /// <reference path="lib/twemoji.d.ts"/>
 3 | 
 4 | class Feed {
 5 | 	constructor(private _url: string, public callback: (data: Tweet) => void) {
 6 | 		this.listen();
 7 | 	}
 8 | 
 9 | 	listen(): void {
10 | 		var ws: WebSocket = new WebSocket(this._url);
11 | 		ws.onopen = this.onOpen;
12 | 		ws.onclose = () => { this.onClose(); };
13 | 		ws.onmessage = (data: any) => { this.onMessage(data); };
14 | 	}
15 | 
16 | 	onOpen(): void {
17 | 		console.log('Socket Opened');
18 | 	}
19 | 
20 | 	onClose(): void  {
21 |         setTimeout(() => { this.listen(); }, 2500);
22 | 		console.log('Socket Closed');
23 | 	}
24 | 
25 | 	onMessage(message: any): void {
26 | 		var data: any = JSON.parse(message.data);
27 | 
28 | 		if (!data.str) {
29 | 			var tweet: Tweet = this.makeTweet(data);
30 | 			this.callback(tweet);
31 | 		}
32 | 	}
33 | 
34 | 	makeTweet(tweet: ITweetData): Tweet {
35 | 		// Format emojis - kinda hacky but it works.
36 | 		tweet.text = twemoji.parse(tweet.text).replace(/36x36/g, '16x16');
37 | 
38 | 		// Determine if they mentioned tweetmap
39 | 		if (tweet.author === 'alexanderurq') {
40 | 			return new Tweet(tweet, MarkerType.King);
41 | 		} else if (tweet.hashtags && tweet.hashtags.indexOf('tweetmap') !== -1) {
42 | 			return new Tweet(tweet, MarkerType.Prince);
43 | 		} else {
44 | 			return new Tweet(tweet);
45 | 		}
46 | 	}
47 | }
48 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/interrupt.go:
--------------------------------------------------------------------------------
 1 | // WARNING: This won't build on Windows and Plan9.
 2 | 
 3 | //
 4 | //  Handling Ctrl-C cleanly in C.
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"log"
14 | 	"os"
15 | 	"os/signal"
16 | 	"syscall"
17 | 	"time"
18 | )
19 | 
20 | func main() {
21 | 	//  Socket to talk to server
22 | 	fmt.Println("Connecting to hello world server...")
23 | 	client, _ := zmq.NewSocket(zmq.REQ)
24 | 	defer client.Close()
25 | 	client.Connect("tcp://localhost:5555")
26 | 
27 | 	// Without signal handling, Go will exit on signal, even if the signal was caught by ZeroMQ
28 | 	chSignal := make(chan os.Signal, 1)
29 | 	signal.Notify(chSignal, syscall.SIGHUP, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
30 | 
31 | LOOP:
32 | 	for {
33 | 		client.Send("HELLO", 0)
34 | 		reply, err := client.Recv(0)
35 | 		if err != nil {
36 | 			if zmq.AsErrno(err) == zmq.Errno(syscall.EINTR) {
37 | 				// signal was caught by 0MQ
38 | 				log.Println("Client Recv:", err)
39 | 				break
40 | 			} else {
41 | 				// some error occured
42 | 				log.Panicln(err)
43 | 			}
44 | 		}
45 | 
46 | 		fmt.Println("Client:", reply)
47 | 		time.Sleep(time.Second)
48 | 
49 | 		select {
50 | 		case sig := <-chSignal:
51 | 			// signal was caught by Go
52 | 			log.Println("Signal:", sig)
53 | 			break LOOP
54 | 		default:
55 | 		}
56 | 	}
57 | }
58 | 


--------------------------------------------------------------------------------
/website/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"github.com/cdn-madness/tweetmap/lib"
 6 | 	"github.com/gorilla/mux"
 7 | 	"io/ioutil"
 8 | 	"net/http"
 9 | 	"os"
10 | )
11 | 
12 | var db *tweetmap.Database
13 | var debug *bool
14 | 
15 | func main() {
16 | 	port := ":8765"
17 | 
18 | 	// Setup debug mode
19 | 	debug = flag.Bool("d", false, "Start server in debug mode")
20 | 	flag.Parse()
21 | 
22 | 	if !*debug {
23 | 		initLogger(ioutil.Discard, ioutil.Discard, os.Stderr)
24 | 	} else {
25 | 		initLogger(os.Stdout, os.Stdout, os.Stderr)
26 | 		Info.Println("Debug Mode")
27 | 	}
28 | 
29 | 	var err error
30 | 	db, err = tweetmap.NewDatabase()
31 | 	if err != nil {
32 | 		Error.Printf("Error connecting to database: %s", err)
33 | 		return
34 | 	}
35 | 	defer db.Disconnect()
36 | 
37 | 	// Start the server
38 | 	router := mux.NewRouter().StrictSlash(true)
39 | 	router.HandleFunc("/tweets/past24hours", queryPast24Hrs)
40 | 	router.HandleFunc("/tweets/ward/{id:[0-9]+}", queryTweetsByWard)
41 | 	router.HandleFunc("/hashtags/past24hours", queryHashtagsPast24Hrs)
42 | 	router.HandleFunc("/hashtags/ward/{id:[0-9]+}", queryHashtagsByWard)
43 | 	router.HandleFunc("/wards/past24hours", queryWardsPast24Hrs)
44 | 
45 | 	router.PathPrefix("/").Handler(http.FileServer(http.Dir("./www/dist/")))
46 | 
47 | 	http.Handle("/", router)
48 | 	Info.Println("Starting server on port: " + port)
49 | 	http.ListenAndServe(port, nil)
50 | }
51 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/taskvent.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Task ventilator.
 3 | //  Binds PUSH socket to tcp://localhost:5557
 4 | //  Sends batch of tasks to workers via that socket
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"math/rand"
14 | 	"time"
15 | )
16 | 
17 | func main() {
18 | 	//  Socket to send messages on
19 | 	sender, _ := zmq.NewSocket(zmq.PUSH)
20 | 	defer sender.Close()
21 | 	sender.Bind("tcp://*:5557")
22 | 
23 | 	//  Socket to send start of batch message on
24 | 	sink, _ := zmq.NewSocket(zmq.PUSH)
25 | 	defer sink.Close()
26 | 	sink.Connect("tcp://localhost:5558")
27 | 
28 | 	fmt.Print("Press Enter when the workers are ready: ")
29 | 	var line string
30 | 	fmt.Scanln(&line)
31 | 	fmt.Println("Sending tasks to workers...")
32 | 
33 | 	//  The first message is "0" and signals start of batch
34 | 	sink.Send("0", 0)
35 | 
36 | 	//  Initialize random number generator
37 | 	rand.Seed(time.Now().UnixNano())
38 | 
39 | 	//  Send 100 tasks
40 | 	total_msec := 0
41 | 	for task_nbr := 0; task_nbr < 100; task_nbr++ {
42 | 		//  Random workload from 1 to 100msecs
43 | 		workload := rand.Intn(100) + 1
44 | 		total_msec += workload
45 | 		s := fmt.Sprintf("%d", workload)
46 | 		sender.Send(s, 0)
47 | 	}
48 | 	fmt.Println("Total expected cost:", time.Duration(total_msec) * time.Millisecond)
49 | 	time.Sleep(time.Second) //  Give 0MQ time to deliver
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013-2014, Peter Kleiweg
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are
 6 | met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright
 9 |    notice, this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright
12 |    notice, this list of conditions and the following disclaimer in the
13 |    documentation and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
16 | IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
17 | TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
18 | PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
21 | TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 | 


--------------------------------------------------------------------------------
/lib/example/feed.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/cdn-madness/tweetmap/lib"
 6 | 	"github.com/cdn-madness/tweetmap/protobuf"
 7 | 	"github.com/darkhelmet/twitterstream"
 8 | 	"os"
 9 | 	"runtime"
10 | 	"time"
11 | )
12 | 
13 | func main() {
14 | 
15 | 	runtime.GOMAXPROCS(runtime.NumCPU())
16 | 
17 | 	// Get environment variables and construct API info
18 | 	apiCfg := tweetmap.TwitterAPIConfig{
19 | 		AccessSecret:   os.Getenv("TWITTER_ACCESS_SECRET"),
20 | 		AccessToken:    os.Getenv("TWITTER_ACCESS_TOKEN"),
21 | 		ConsumerSecret: os.Getenv("TWITTER_CONSUMER_SECRET"),
22 | 		ConsumerKey:    os.Getenv("TWITTER_CONSUMER_KEY"),
23 | 		SouthEast:      twitterstream.Point{0, 0},
24 | 		NorthWest:      twitterstream.Point{90, 180},
25 | 	}
26 | 
27 | 	filter := func(t *twitterstream.Tweet) bool {
28 | 		return true
29 | 	}
30 | 
31 | 	doneChan := make(chan bool)
32 | 	tweetChan, errChan := tweetmap.ListenToTwitter(apiCfg, filter, doneChan)
33 | 
34 | 	go func(tc chan *prototweet.Tweet) {
35 | 		for tweet := range tc {
36 | 			fmt.Printf("Received tweet from %s\n", tweet.User)
37 | 		}
38 | 		fmt.Println("Exiting tweet function\n")
39 | 	}(tweetChan)
40 | 
41 | 	go func(ec chan error) {
42 | 		for err := range ec {
43 | 			fmt.Printf("Error: %s\n", err.Error())
44 | 		}
45 | 		fmt.Println("Exiting error function\n")
46 | 	}(errChan)
47 | 
48 | 	time.Sleep(10 * time.Second)
49 | 	close(doneChan)
50 | 	time.Sleep(100 * time.Second)
51 | }
52 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/flserver3.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Freelance server - Model 3.
 3 | //  Uses an ROUTER/ROUTER socket but just one thread
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"os"
13 | )
14 | 
15 | func main() {
16 | 	var verbose bool
17 | 	if len(os.Args) > 1 && os.Args[1] == "-v" {
18 | 		verbose = true
19 | 	}
20 | 
21 | 	//  Prepare server socket with predictable identity
22 | 	bind_endpoint := "tcp://*:5555"
23 | 	connect_endpoint := "tcp://localhost:5555"
24 | 	server, _ := zmq.NewSocket(zmq.ROUTER)
25 | 	server.SetIdentity(connect_endpoint)
26 | 	server.Bind(bind_endpoint)
27 | 	fmt.Println("I: service is ready at", bind_endpoint)
28 | 
29 | 	for {
30 | 		request, err := server.RecvMessage(0)
31 | 		if err != nil {
32 | 			break
33 | 		}
34 | 		if verbose {
35 | 			fmt.Printf("%q\n", request)
36 | 		}
37 | 
38 | 		//  Frame 0: identity of client
39 | 		//  Frame 1: PING, or client control frame
40 | 		//  Frame 2: request body
41 | 		identity := request[0]
42 | 		control := request[1]
43 | 		reply := make([]string, 1, 3)
44 | 		if control == "PING" {
45 | 			reply = append(reply, "PONG")
46 | 		} else {
47 | 			reply = append(reply, control)
48 | 			reply = append(reply, "OK")
49 | 		}
50 | 		reply[0] = identity
51 | 		if verbose {
52 | 			fmt.Printf("%q\n", reply)
53 | 		}
54 | 		server.SendMessage(reply)
55 | 	}
56 | 	fmt.Println("W: interrupted")
57 | }
58 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/url_test.go:
--------------------------------------------------------------------------------
 1 | package pq
 2 | 
 3 | import (
 4 | 	"testing"
 5 | )
 6 | 
 7 | func TestSimpleParseURL(t *testing.T) {
 8 | 	expected := "host=hostname.remote"
 9 | 	str, err := ParseURL("postgres://hostname.remote")
10 | 	if err != nil {
11 | 		t.Fatal(err)
12 | 	}
13 | 
14 | 	if str != expected {
15 | 		t.Fatalf("unexpected result from ParseURL:\n+ %v\n- %v", str, expected)
16 | 	}
17 | }
18 | 
19 | func TestFullParseURL(t *testing.T) {
20 | 	expected := `dbname=database host=hostname.remote password=top\ secret port=1234 user=username`
21 | 	str, err := ParseURL("postgres://username:top%20secret@hostname.remote:1234/database")
22 | 	if err != nil {
23 | 		t.Fatal(err)
24 | 	}
25 | 
26 | 	if str != expected {
27 | 		t.Fatalf("unexpected result from ParseURL:\n+ %s\n- %s", str, expected)
28 | 	}
29 | }
30 | 
31 | func TestInvalidProtocolParseURL(t *testing.T) {
32 | 	_, err := ParseURL("http://hostname.remote")
33 | 	switch err {
34 | 	case nil:
35 | 		t.Fatal("Expected an error from parsing invalid protocol")
36 | 	default:
37 | 		msg := "invalid connection protocol: http"
38 | 		if err.Error() != msg {
39 | 			t.Fatalf("Unexpected error message:\n+ %s\n- %s",
40 | 				err.Error(), msg)
41 | 		}
42 | 	}
43 | }
44 | 
45 | func TestMinimalURL(t *testing.T) {
46 | 	cs, err := ParseURL("postgres://")
47 | 	if err != nil {
48 | 		t.Fatal(err)
49 | 	}
50 | 
51 | 	if cs != "" {
52 | 		t.Fatalf("expected blank connection string, got: %q", cs)
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/udpping2.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  UDP ping command
 3 | //  Model 2, uses the GO net library
 4 | //
 5 | 
 6 | //  this doesn't use ZeroMQ at all
 7 | 
 8 | package main
 9 | 
10 | import (
11 | 	"fmt"
12 | 	"log"
13 | 	"net"
14 | 	"time"
15 | )
16 | 
17 | const (
18 | 	PING_PORT_NUMBER = 9999
19 | 	PING_MSG_SIZE    = 1
20 | 	PING_INTERVAL    = 1000 * time.Millisecond //  Once per second
21 | )
22 | 
23 | func main() {
24 | 
25 | 	log.SetFlags(log.Lshortfile)
26 | 
27 | 	//  Create UDP socket
28 | 	bcast := &net.UDPAddr{Port: PING_PORT_NUMBER, IP: net.IPv4bcast}
29 | 	conn, err := net.ListenUDP("udp", bcast)
30 | 	if err != nil {
31 | 		log.Fatalln(err)
32 | 	}
33 | 
34 | 	buffer := make([]byte, PING_MSG_SIZE)
35 | 
36 | 	//  We send a beacon once a second, and we collect and report
37 | 	//  beacons that come in from other nodes:
38 | 
39 | 	//  Send first ping right away
40 | 	ping_at := time.Now()
41 | 
42 | 	for {
43 | 		if err := conn.SetReadDeadline(ping_at); err != nil {
44 | 			log.Fatalln(err)
45 | 		}
46 | 
47 | 		if _, addr, err := conn.ReadFrom(buffer); err == nil {
48 | 			//  Someone answered our ping
49 | 			fmt.Println("Found peer", addr)
50 | 		}
51 | 
52 | 		if time.Now().After(ping_at) {
53 | 			//  Broadcast our beacon
54 | 			fmt.Println("Pinging peers...")
55 | 			buffer[0] = '!'
56 | 			if _, err := conn.WriteTo(buffer, bcast); err != nil {
57 | 				log.Fatalln(err)
58 | 			}
59 | 			ping_at = time.Now().Add(PING_INTERVAL)
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/spworker.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Simple Pirate worker.
 3 | //  Connects REQ socket to tcp://*:5556
 4 | //  Implements worker part of load-balancing
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"math/rand"
14 | 	"time"
15 | )
16 | 
17 | const (
18 | 	WORKER_READY = "\001" //  Signals worker is ready
19 | )
20 | 
21 | func main() {
22 | 	worker, _ := zmq.NewSocket(zmq.REQ)
23 | 	defer worker.Close()
24 | 
25 | 	//  Set random identity to make tracing easier
26 | 	rand.Seed(time.Now().UnixNano())
27 | 	identity := fmt.Sprintf("%04X-%04X", rand.Intn(0x10000), rand.Intn(0x10000))
28 | 	worker.SetIdentity(identity)
29 | 	worker.Connect("tcp://localhost:5556")
30 | 
31 | 	//  Tell broker we're ready for work
32 | 	fmt.Printf("I: (%s) worker ready\n", identity)
33 | 	worker.Send(WORKER_READY, 0)
34 | 
35 | 	for cycles := 0; true; {
36 | 		msg, err := worker.RecvMessage(0)
37 | 		if err != nil {
38 | 			break //  Interrupted
39 | 		}
40 | 
41 | 		//  Simulate various problems, after a few cycles
42 | 		cycles++
43 | 		if cycles > 3 && rand.Intn(5) == 0 {
44 | 			fmt.Printf("I: (%s) simulating a crash\n", identity)
45 | 			break
46 | 		} else if cycles > 3 && rand.Intn(5) == 0 {
47 | 			fmt.Printf("I: (%s) simulating CPU overload\n", identity)
48 | 			time.Sleep(3 * time.Second)
49 | 		}
50 | 
51 | 		fmt.Printf("I: (%s) normal reply\n", identity)
52 | 		time.Sleep(time.Second) //  Do some heavy work
53 | 		worker.SendMessage(msg)
54 | 	}
55 | }
56 | 


--------------------------------------------------------------------------------
/website/handlers.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/cdn-madness/tweetmap/lib"
 6 | 	"github.com/gorilla/mux"
 7 | 	"net/http"
 8 | )
 9 | 
10 | func writeResult(res []byte, err error, w http.ResponseWriter, r *http.Request) {
11 | 	if err != nil {
12 | 		w.WriteHeader(500)
13 | 		fmt.Fprintf(w, "Database Error: %s", err)
14 | 
15 | 		if *debug {
16 | 			Error.Printf("Database Error: %s\n", err)
17 | 		}
18 | 		return
19 | 	}
20 | 
21 | 	if *debug {
22 | 		w.Header().Set("Access-Control-Allow-Origin", "*")
23 | 		Info.Printf("Request:\t%s\tFrom: %s\n", r.RequestURI, r.RemoteAddr)
24 | 	}
25 | 
26 | 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
27 | 	w.Write(res)
28 | }
29 | 
30 | func queryPast24Hrs(w http.ResponseWriter, r *http.Request) {
31 | 	result, err := db.Query(tweetmap.TWEETS_PAST_24HRS)
32 | 	writeResult(result, err, w, r)
33 | }
34 | 
35 | func queryHashtagsPast24Hrs(w http.ResponseWriter, r *http.Request) {
36 | 	result, err := db.Query(tweetmap.TOP_HASH_PAST_24HRS)
37 | 	writeResult(result, err, w, r)
38 | }
39 | 
40 | func queryWardsPast24Hrs(w http.ResponseWriter, r *http.Request) {
41 | 	result, err := db.Query(tweetmap.TWEETS_BY_WARD)
42 | 	writeResult(result, err, w, r)
43 | }
44 | 
45 | func queryTweetsByWard(w http.ResponseWriter, r *http.Request) {
46 | 	result, err := db.Query(tweetmap.TWEETS_BY_WARD)
47 | 	writeResult(result, err, w, r)
48 | }
49 | 
50 | func queryHashtagsByWard(w http.ResponseWriter, r *http.Request) {
51 | 	fmt.Fprintf(w, "ID: %s", mux.Vars(r)["id"])
52 | }
53 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/buf.go:
--------------------------------------------------------------------------------
 1 | package pq
 2 | 
 3 | import (
 4 | 	"bytes"
 5 | 	"encoding/binary"
 6 | 	"github.com/lib/pq/oid"
 7 | )
 8 | 
 9 | type readBuf []byte
10 | 
11 | func (b *readBuf) int32() (n int) {
12 | 	n = int(int32(binary.BigEndian.Uint32(*b)))
13 | 	*b = (*b)[4:]
14 | 	return
15 | }
16 | 
17 | func (b *readBuf) oid() (n oid.Oid) {
18 | 	n = oid.Oid(binary.BigEndian.Uint32(*b))
19 | 	*b = (*b)[4:]
20 | 	return
21 | }
22 | 
23 | func (b *readBuf) int16() (n int) {
24 | 	n = int(binary.BigEndian.Uint16(*b))
25 | 	*b = (*b)[2:]
26 | 	return
27 | }
28 | 
29 | func (b *readBuf) string() string {
30 | 	i := bytes.IndexByte(*b, 0)
31 | 	if i < 0 {
32 | 		errorf("invalid message format; expected string terminator")
33 | 	}
34 | 	s := (*b)[:i]
35 | 	*b = (*b)[i+1:]
36 | 	return string(s)
37 | }
38 | 
39 | func (b *readBuf) next(n int) (v []byte) {
40 | 	v = (*b)[:n]
41 | 	*b = (*b)[n:]
42 | 	return
43 | }
44 | 
45 | func (b *readBuf) byte() byte {
46 | 	return b.next(1)[0]
47 | }
48 | 
49 | type writeBuf []byte
50 | 
51 | func (b *writeBuf) int32(n int) {
52 | 	x := make([]byte, 4)
53 | 	binary.BigEndian.PutUint32(x, uint32(n))
54 | 	*b = append(*b, x...)
55 | }
56 | 
57 | func (b *writeBuf) int16(n int) {
58 | 	x := make([]byte, 2)
59 | 	binary.BigEndian.PutUint16(x, uint16(n))
60 | 	*b = append(*b, x...)
61 | }
62 | 
63 | func (b *writeBuf) string(s string) {
64 | 	*b = append(*b, (s + "\000")...)
65 | }
66 | 
67 | func (b *writeBuf) byte(c byte) {
68 | 	*b = append(*b, c)
69 | }
70 | 
71 | func (b *writeBuf) bytes(v []byte) {
72 | 	*b = append(*b, v...)
73 | }
74 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/certs/root.crt:
--------------------------------------------------------------------------------
 1 | -----BEGIN CERTIFICATE-----
 2 | MIIEAzCCAuugAwIBAgIJANmheROCdW1NMA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV
 3 | BAYTAlVTMQ8wDQYDVQQIEwZOZXZhZGExEjAQBgNVBAcTCUxhcyBWZWdhczEaMBgG
 4 | A1UEChMRZ2l0aHViLmNvbS9saWIvcHExDjAMBgNVBAMTBXBxIENBMB4XDTE0MTAx
 5 | MTE1MDQyOVoXDTI0MTAwODE1MDQyOVowXjELMAkGA1UEBhMCVVMxDzANBgNVBAgT
 6 | Bk5ldmFkYTESMBAGA1UEBxMJTGFzIFZlZ2FzMRowGAYDVQQKExFnaXRodWIuY29t
 7 | L2xpYi9wcTEOMAwGA1UEAxMFcHEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
 8 | ggEKAoIBAQCV4PxP7ShzWBzUCThcKk3qZtOLtHmszQVtbqhvgTpm1kTRtKBdVMu0
 9 | pLAHQ3JgJCnAYgH0iZxVGoMP16T3irdgsdC48+nNTFM2T0cCdkfDURGIhSFN47cb
10 | Pgy306BcDUD2q7ucW33+dlFSRuGVewocoh4BWM/vMtMvvWzdi4Ag/L/jhb+5wZxZ
11 | sWymsadOVSDePEMKOvlCa3EdVwVFV40TVyDb+iWBUivDAYsS2a3KajuJrO6MbZiE
12 | Sp2RCIkZS2zFmzWxVRi9ZhzIZhh7EVF9JAaNC3T52jhGUdlRq3YpBTMnd89iOh74
13 | 6jWXG7wSuPj3haFzyNhmJ0ZUh+2Ynoh1AgMBAAGjgcMwgcAwHQYDVR0OBBYEFFKT
14 | 7R52Cp9lT94ZZsHVIkA1y6ByMIGQBgNVHSMEgYgwgYWAFFKT7R52Cp9lT94ZZsHV
15 | IkA1y6ByoWKkYDBeMQswCQYDVQQGEwJVUzEPMA0GA1UECBMGTmV2YWRhMRIwEAYD
16 | VQQHEwlMYXMgVmVnYXMxGjAYBgNVBAoTEWdpdGh1Yi5jb20vbGliL3BxMQ4wDAYD
17 | VQQDEwVwcSBDQYIJANmheROCdW1NMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEF
18 | BQADggEBAAEhCLWkqJNMI8b4gkbmj5fqQ/4+oO83bZ3w2Oqf6eZ8I8BC4f2NOyE6
19 | tRUlq5+aU7eqC1cOAvGjO+YHN/bF/DFpwLlzvUSXt+JP/pYcUjL7v+pIvwqec9hD
20 | ndvM4iIbkD/H/OYQ3L+N3W+G1x7AcFIX+bGCb3PzYVQAjxreV6//wgKBosMGFbZo
21 | HPxT9RPMun61SViF04H5TNs0derVn1+5eiiYENeAhJzQNyZoOOUuX1X/Inx9bEPh
22 | C5vFBtSMgIytPgieRJVWAiMLYsfpIAStrHztRAbBs2DU01LmMgRvHdxgFEKinC/d
23 | UHZZQDP+6pT+zADrGhQGXe4eThaO6f0=
24 | -----END CERTIFICATE-----
25 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/identity.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Demonstrate identities as used by the request-reply pattern.
 3 | //  Run this program by itself.
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"regexp"
13 | )
14 | 
15 | var (
16 | 	all_char = regexp.MustCompile("^[^[:cntrl:]]*$")
17 | )
18 | 
19 | func main() {
20 | 	sink, _ := zmq.NewSocket(zmq.ROUTER)
21 | 	defer sink.Close()
22 | 	sink.Bind("inproc://example")
23 | 
24 | 	//  First allow 0MQ to set the identity
25 | 	anonymous, _ := zmq.NewSocket(zmq.REQ)
26 | 	defer anonymous.Close()
27 | 	anonymous.Connect("inproc://example")
28 | 	anonymous.Send("ROUTER uses a generated UUID", 0)
29 | 	dump(sink)
30 | 
31 | 	//  Then set the identity ourselves
32 | 	identified, _ := zmq.NewSocket(zmq.REQ)
33 | 	defer identified.Close()
34 | 	identified.SetIdentity("PEER2")
35 | 	identified.Connect("inproc://example")
36 | 	identified.Send("ROUTER socket uses REQ's socket identity", 0)
37 | 	dump(sink)
38 | }
39 | 
40 | func dump(soc *zmq.Socket) {
41 | 	fmt.Println("----------------------------------------")
42 | 	for {
43 | 		//  Process all parts of the message
44 | 		message, _ := soc.Recv(0)
45 | 
46 | 		//  Dump the message as text or binary
47 | 		fmt.Printf("[%03d] ", len(message))
48 | 		if all_char.MatchString(message) {
49 | 			fmt.Print(message)
50 | 		} else {
51 | 			for i := 0; i < len(message); i++ {
52 | 				fmt.Printf("%02X ", message[i])
53 | 			}
54 | 		}
55 | 		fmt.Println()
56 | 
57 | 		more, _ := soc.GetRcvmore()
58 | 		if !more {
59 | 			break
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples_security/woodhouse.go:
--------------------------------------------------------------------------------
 1 | //  The Woodhouse Pattern
 2 | //
 3 | //  It may keep some malicious people out but all it takes is a bit
 4 | //  of network sniffing, and they'll be able to fake their way in.
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"log"
13 | 	"runtime"
14 | )
15 | 
16 | func main() {
17 | 
18 | 	//  Start authentication engine
19 | 	zmq.AuthSetVerbose(true)
20 | 	zmq.AuthStart()
21 | 	zmq.AuthAllow("domain1", "127.0.0.1")
22 | 
23 | 	//  Tell the authenticator how to handle PLAIN requests
24 | 	zmq.AuthPlainAdd("domain1", "admin", "secret")
25 | 
26 | 	//  Create and bind server socket
27 | 	server, _ := zmq.NewSocket(zmq.PUSH)
28 | 	server.ServerAuthPlain("domain1")
29 | 	server.Bind("tcp://*:9000")
30 | 
31 | 	//  Create and connect client socket
32 | 	client, _ := zmq.NewSocket(zmq.PULL)
33 | 	client.SetPlainUsername("admin")
34 | 	client.SetPlainPassword("secret")
35 | 	client.Connect("tcp://127.0.0.1:9000")
36 | 
37 | 	//  Send a single message from server to client
38 | 	_, err := server.Send("Hello", 0)
39 | 	checkErr(err)
40 | 	message, err := client.Recv(0)
41 | 	checkErr(err)
42 | 	if message != "Hello" {
43 | 		log.Fatalln(message, "!= Hello")
44 | 	}
45 | 
46 | 	zmq.AuthStop()
47 | 
48 | 	fmt.Println("Woodhouse test OK")
49 | 
50 | }
51 | 
52 | func checkErr(err error) {
53 | 	if err != nil {
54 | 		log.SetFlags(0)
55 | 		_, filename, lineno, ok := runtime.Caller(1)
56 | 		if ok {
57 | 			log.Fatalf("%v:%v: %v", filename, lineno, err)
58 | 		} else {
59 | 			log.Fatalln(err)
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/oid/gen.go:
--------------------------------------------------------------------------------
 1 | // +build ignore
 2 | 
 3 | // Generate the table of OID values
 4 | // Run with 'go run gen.go'.
 5 | package main
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"log"
10 | 	"os"
11 | 	"os/exec"
12 | 
13 | 	"database/sql"
14 | 	_ "github.com/lib/pq"
15 | )
16 | 
17 | func main() {
18 | 	datname := os.Getenv("PGDATABASE")
19 | 	sslmode := os.Getenv("PGSSLMODE")
20 | 
21 | 	if datname == "" {
22 | 		os.Setenv("PGDATABASE", "pqgotest")
23 | 	}
24 | 
25 | 	if sslmode == "" {
26 | 		os.Setenv("PGSSLMODE", "disable")
27 | 	}
28 | 
29 | 	db, err := sql.Open("postgres", "")
30 | 	if err != nil {
31 | 		log.Fatal(err)
32 | 	}
33 | 	cmd := exec.Command("gofmt")
34 | 	cmd.Stderr = os.Stderr
35 | 	w, err := cmd.StdinPipe()
36 | 	if err != nil {
37 | 		log.Fatal(err)
38 | 	}
39 | 	f, err := os.Create("types.go")
40 | 	if err != nil {
41 | 		log.Fatal(err)
42 | 	}
43 | 	cmd.Stdout = f
44 | 	err = cmd.Start()
45 | 	if err != nil {
46 | 		log.Fatal(err)
47 | 	}
48 | 	fmt.Fprintln(w, "// generated by 'go run gen.go'; do not edit")
49 | 	fmt.Fprintln(w, "\npackage oid")
50 | 	fmt.Fprintln(w, "const (")
51 | 	rows, err := db.Query(`
52 | 		SELECT typname, oid
53 | 		FROM pg_type WHERE oid < 10000
54 | 		ORDER BY oid;
55 | 	`)
56 | 	if err != nil {
57 | 		log.Fatal(err)
58 | 	}
59 | 	var name string
60 | 	var oid int
61 | 	for rows.Next() {
62 | 		err = rows.Scan(&name, &oid)
63 | 		if err != nil {
64 | 			log.Fatal(err)
65 | 		}
66 | 		fmt.Fprintf(w, "T_%s Oid = %d\n", name, oid)
67 | 	}
68 | 	if err = rows.Err(); err != nil {
69 | 		log.Fatal(err)
70 | 	}
71 | 	fmt.Fprintln(w, ")")
72 | 	w.Close()
73 | 	cmd.Wait()
74 | }
75 | 


--------------------------------------------------------------------------------
/lib/network_test.go:
--------------------------------------------------------------------------------
 1 | package tweetmap
 2 | 
 3 | import (
 4 | 	"github.com/cdn-madness/tweetmap/protobuf"
 5 | 	"github.com/stretchr/testify/assert"
 6 | 	"testing"
 7 | 	"time"
 8 | )
 9 | 
10 | const CONNSTR string = "ipc:///tmp/testfeed"
11 | 
12 | func TestInitPublisher(t *testing.T) {
13 | 	tweetChan := make(chan *prototweet.Tweet)
14 | 	errorChan := make(chan error)
15 | 
16 | 	select {
17 | 	case err := <-errorChan:
18 | 		assert.Fail(t, err.Error())
19 | 	default:
20 | 		InitPublisher(CONNSTR, tweetChan, errorChan)
21 | 		tweet := &prototweet.Tweet{}
22 | 		tweetChan <- tweet
23 | 		close(tweetChan)
24 | 	}
25 | }
26 | 
27 | func TestInitReceiver(t *testing.T) {
28 | 	// Start publishing tweets
29 | 	go func() {
30 | 		tweetChan := make(chan *prototweet.Tweet)
31 | 		errorChan := make(chan error)
32 | 		InitPublisher(CONNSTR, tweetChan, errorChan)
33 | 		tweet := &prototweet.Tweet{}
34 | 
35 | 		for i := 0; i < 5; i++ {
36 | 			select {
37 | 			case err := <-errorChan:
38 | 				t.Logf("Error Received: %s", err)
39 | 				assert.Fail(t, "Test failed")
40 | 			case <-time.After(50 * time.Millisecond):
41 | 				tweetChan <- tweet
42 | 			}
43 | 		}
44 | 		close(tweetChan)
45 | 	}()
46 | 
47 | 	// First set up the channels
48 | 	doneChan := make(chan bool)
49 | 
50 | 	tweetChan, errChan := InitReceiver(CONNSTR, doneChan)
51 | 	received := false
52 | L:
53 | 	for received == false {
54 | 		select {
55 | 		case err := <-errChan:
56 | 			assert.Fail(t, err.Error())
57 | 			break L
58 | 		case <-tweetChan:
59 | 			received = true
60 | 			close(doneChan)
61 | 		case <-time.After(1 * time.Second):
62 | 			break L
63 | 		}
64 | 	}
65 | 	assert.True(t, received)
66 | }
67 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/taskwork2.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Task worker - design 2.
 3 | //  Adds pub-sub flow to receive and respond to kill signal
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"strconv"
13 | 	"time"
14 | )
15 | 
16 | func main() {
17 | 	//  Socket to receive messages on
18 | 	receiver, _ := zmq.NewSocket(zmq.PULL)
19 | 	defer receiver.Close()
20 | 	receiver.Connect("tcp://localhost:5557")
21 | 
22 | 	//  Socket to send messages to
23 | 	sender, _ := zmq.NewSocket(zmq.PUSH)
24 | 	defer sender.Close()
25 | 	sender.Connect("tcp://localhost:5558")
26 | 
27 | 	//  Socket for control input
28 | 	controller, _ := zmq.NewSocket(zmq.SUB)
29 | 	defer controller.Close()
30 | 	controller.Connect("tcp://localhost:5559")
31 | 	controller.SetSubscribe("")
32 | 
33 | 	//  Process messages from receiver and controller
34 | 	poller := zmq.NewPoller()
35 | 	poller.Add(receiver, zmq.POLLIN)
36 | 	poller.Add(controller, zmq.POLLIN)
37 | 	//  Process messages from both sockets
38 | LOOP:
39 | 	for {
40 | 		sockets, _ := poller.Poll(-1)
41 | 		for _, socket := range sockets {
42 | 			switch s := socket.Socket; s {
43 | 			case receiver:
44 | 				msg, _ := s.Recv(0)
45 | 
46 | 				//  Do the work
47 | 				t, _ := strconv.Atoi(msg)
48 | 				time.Sleep(time.Duration(t) * time.Millisecond)
49 | 
50 | 				//  Send results to sink
51 | 				sender.Send(msg, 0)
52 | 
53 | 				//  Simple progress indicator for the viewer
54 | 				fmt.Printf(".")
55 | 			case controller:
56 | 				//  Any controller command acts as 'KILL'
57 | 				break LOOP //  Exit loop
58 | 			}
59 | 		}
60 | 	}
61 | 	fmt.Println()
62 | }
63 | 


--------------------------------------------------------------------------------
/website/www/src/js/Chart.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="lib/jquery.d.ts"/>
 2 | /// <reference path="lib/c3.d.ts"/>
 3 | /// <reference path="API.ts"/>
 4 | 
 5 | class Chart {
 6 | 	constructor(public node: string, public API: API) { }
 7 | 
 8 | 	activate(): void {
 9 | 		return;
10 | 	}
11 | 
12 | 	resize(): void {
13 | 		return;
14 | 	}
15 | }
16 | 
17 | class Last24HoursChart extends Chart {
18 | 	private _data: any;
19 | 	private _chart: any;
20 | 
21 | 	constructor(node: string, API: API) {
22 | 		super(node, API);
23 | 
24 | 		// Get the data for the chart
25 | 		this.API.getTweetData('tweets/past24hours', (data: any) => {
26 | 			this._data = $.map(data, function(el: any): any {
27 | 				el.hour = el.hour * 1000;
28 | 				return el;
29 | 			});
30 | 
31 | 			this.activate();
32 | 		});
33 | 	}
34 | 
35 | 	activate(): void {
36 | 		this._chart = c3.generate({
37 | 			bindTo: this.node,
38 | 			data: {
39 | 			    json: this._data,
40 | 			    keys: {
41 | 			        x: 'hour',
42 | 			        value: ['count', 'average']
43 | 			    },
44 | 			    names: {
45 | 			        count: 'Observed',
46 | 			        average: 'Weekly Average'
47 | 			    },
48 | 			    colors: {
49 | 			    	count: '#E8EEFF',
50 | 			    	average: '#383C47'
51 | 			    },
52 | 			    type: 'spline'
53 | 			},
54 | 			axis: {
55 | 			    x: {
56 | 			        type: 'timeseries'
57 | 			    }
58 | 			},
59 | 			grid: {
60 | 			    x: {
61 | 			        show: true
62 | 			    },
63 | 			    y: {
64 | 			        show: true
65 | 			    }
66 | 			},
67 | 			tooltip: {
68 | 				format: {
69 | 					title: function(d: Date): string { return d.toDateString() + ' ' + d.getHours() + ':00'; }
70 | 				}
71 | 			}
72 | 		});
73 | 	}
74 | }
75 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/syncpub.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Synchronized publisher.
 3 | //
 4 | //  This diverts from the C example by introducing time delays.
 5 | //  Without these delays, the subscribers won't catch the END message.
 6 | //
 7 | 
 8 | package main
 9 | 
10 | import (
11 | 	zmq "github.com/pebbe/zmq4"
12 | 
13 | 	"fmt"
14 | 	"time"
15 | )
16 | 
17 | const (
18 | 	//  We wait for 10 subscribers
19 | 	SUBSCRIBERS_EXPECTED = 10
20 | )
21 | 
22 | func main() {
23 | 
24 | 	//  Socket to talk to clients
25 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
26 | 	defer publisher.Close()
27 | 	publisher.Bind("tcp://*:5561")
28 | 
29 | 	//  Socket to receive signals
30 | 	syncservice, _ := zmq.NewSocket(zmq.REP)
31 | 	defer syncservice.Close()
32 | 	syncservice.Bind("tcp://*:5562")
33 | 
34 | 	//  Get synchronization from subscribers
35 | 	fmt.Println("Waiting for subscribers")
36 | 	for subscribers := 0; subscribers < SUBSCRIBERS_EXPECTED; subscribers++ {
37 | 		//  - wait for synchronization request
38 | 		syncservice.Recv(0)
39 | 		//  - send synchronization reply
40 | 		syncservice.Send("", 0)
41 | 	}
42 | 	//  Now broadcast exactly 1M updates followed by END
43 | 	fmt.Println("Broadcasting messages")
44 | 	for update_nbr := 0; update_nbr < 1000000; update_nbr++ {
45 | 		publisher.Send("Rhubarb", 0)
46 | 		// subscribers don't get all messages if publisher is too fast
47 | 		// a one microsecond pause may still be too short
48 | 		time.Sleep(time.Microsecond)
49 | 	}
50 | 
51 | 	// a longer pause ensures subscribers are ready to receive this
52 | 	time.Sleep(time.Second)
53 | 	publisher.Send("END", 0)
54 | 
55 | 	// what's another second?
56 | 	time.Sleep(time.Second)
57 | }
58 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/connection.go:
--------------------------------------------------------------------------------
 1 | package twitterstream
 2 | 
 3 | import (
 4 |     "encoding/json"
 5 |     "io"
 6 |     "net"
 7 |     "net/http"
 8 |     "time"
 9 | )
10 | 
11 | const DialTimeout = 5 * time.Second
12 | 
13 | type Connection struct {
14 |     decoder *json.Decoder
15 |     conn    net.Conn
16 |     client  *http.Client
17 |     closer  io.Closer
18 |     timeout time.Duration
19 | }
20 | 
21 | func (c *Connection) Close() error {
22 |     // Have to close the raw connection, since closing the response body reader
23 |     // will make Go try to read the request, which goes on forever.
24 |     if err := c.conn.Close(); err != nil {
25 |         c.closer.Close()
26 |         return err
27 |     }
28 |     return c.closer.Close()
29 | }
30 | 
31 | func (c *Connection) Next() (*Tweet, error) {
32 |     var tweet Tweet
33 |     if c.timeout != 0 {
34 |         c.conn.SetReadDeadline(time.Now().Add(c.timeout))
35 |     }
36 |     if err := c.decoder.Decode(&tweet); err != nil {
37 |         return nil, err
38 |     }
39 |     return &tweet, nil
40 | }
41 | 
42 | func (c *Connection) setup(rc io.ReadCloser) {
43 |     c.closer = rc
44 |     c.decoder = json.NewDecoder(rc)
45 | }
46 | 
47 | func newConnection(timeout time.Duration) *Connection {
48 |     conn := &Connection{timeout: timeout}
49 |     dialer := func(netw, addr string) (net.Conn, error) {
50 |         netc, err := net.DialTimeout(netw, addr, DialTimeout)
51 |         if err != nil {
52 |             return nil, err
53 |         }
54 |         conn.conn = netc
55 |         return netc, nil
56 |     }
57 | 
58 |     conn.client = &http.Client{
59 |         Transport: &http.Transport{
60 |             Dial: dialer,
61 |         },
62 |     }
63 | 
64 |     return conn
65 | }
66 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples_security/strawhouse.go:
--------------------------------------------------------------------------------
 1 | //  The Strawhouse Pattern
 2 | //
 3 | //  We allow or deny clients according to their IP address. It may keep
 4 | //  spammers and idiots away, but won't stop a real attacker for more
 5 | //  than a heartbeat.
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"log"
14 | 	"runtime"
15 | )
16 | 
17 | func main() {
18 | 
19 | 	//  Get some indication of what the authenticator is deciding
20 | 	zmq.AuthSetVerbose(true)
21 | 
22 | 	//  Start the authentication engine. This engine
23 | 	//  allows or denies incoming connections (talking to the libzmq
24 | 	//  core over a protocol called ZAP).
25 | 	zmq.AuthStart()
26 | 
27 | 	//  Whitelist our address; any other address will be rejected
28 | 	zmq.AuthAllow("domain1", "127.0.0.1")
29 | 
30 | 	//  Create and bind server socket
31 | 	server, err := zmq.NewSocket(zmq.PUSH)
32 | 	checkErr(err)
33 | 	server.ServerAuthNull("domain1")
34 | 	server.Bind("tcp://*:9000")
35 | 
36 | 	//  Create and connect client socket
37 | 	client, err := zmq.NewSocket(zmq.PULL)
38 | 	checkErr(err)
39 | 	checkErr(client.Connect("tcp://127.0.0.1:9000"))
40 | 
41 | 	//  Send a single message from server to client
42 | 	_, err = server.Send("Hello", 0)
43 | 	checkErr(err)
44 | 	message, err := client.Recv(0)
45 | 	checkErr(err)
46 | 	if message != "Hello" {
47 | 		log.Fatalln(message, "!= Hello")
48 | 	}
49 | 
50 | 	zmq.AuthStop()
51 | 
52 | 	fmt.Println("Strawhouse test OK")
53 | }
54 | 
55 | func checkErr(err error) {
56 | 	if err != nil {
57 | 		log.SetFlags(0)
58 | 		_, filename, lineno, ok := runtime.Caller(1)
59 | 		if ok {
60 | 			log.Fatalf("%v:%v: %v", filename, lineno, err)
61 | 		} else {
62 | 			log.Fatalln(err)
63 | 		}
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/certs/server.key:
--------------------------------------------------------------------------------
 1 | -----BEGIN RSA PRIVATE KEY-----
 2 | MIIEogIBAAKCAQEA14pMhfsXpTyP4HIRKc4/sB8/fcbuf6f8Ais1RwimPZDfXFYU
 3 | lADHbdHS4mGVd7jjpmYx+R8hfWLhJ9qUN2FK6mNToGG4nLul4ue3ptgPBQTHKeLq
 4 | SSt/3hUAphhwUMcM3pr5Wpaw4ZQGxm1KITu0D6VtkoY0sk7XDqcZwHcLe4fIkt5C
 5 | /4bSt5qk1BUjyq2laSG4zn5my4Vdue2LLQmNlOQEHnLs79B2kBVapPeRS+nOTp1d
 6 | mnAXnNjpc4PqPWGZps2skUBaiHflTiqOPRPz+ThvgWuKlcoOB6tv2rSM2f+qeAOq
 7 | x8LPb2SS09iD1a/xIxinLnsXC+d98fqoQaMEVwIDAQABAoIBAF3ZoihUhJ82F4+r
 8 | Gz4QyDpv4L1reT2sb1aiabhcU8ZK5nbWJG+tRyjSS/i2dNaEcttpdCj9HR/zhgZM
 9 | bm0OuAgG58rVwgS80CZUruq++Qs+YVojq8/gWPTiQD4SNhV2Fmx3HkwLgUk3oxuT
10 | SsvdqzGE3okGVrutCIcgy126eA147VPMoej1Bb3fO6npqK0pFPhZfAc0YoqJuM+k
11 | obRm5pAnGUipyLCFXjA9HYPKwYZw2RtfdA3CiImHeanSdqS+ctrC9y8BV40Th7gZ
12 | haXdKUNdjmIxV695QQ1mkGqpKLZFqhzKioGQ2/Ly2d1iaKN9fZltTusu8unepWJ2
13 | tlT9qMECgYEA9uHaF1t2CqE+AJvWTihHhPIIuLxoOQXYea1qvxfcH/UMtaLKzCNm
14 | lQ5pqCGsPvp+10f36yttO1ZehIvlVNXuJsjt0zJmPtIolNuJY76yeussfQ9jHheB
15 | 5uPEzCFlHzxYbBUyqgWaF6W74okRGzEGJXjYSP0yHPPdU4ep2q3bGiUCgYEA34Af
16 | wBSuQSK7uLxArWHvQhyuvi43ZGXls6oRGl+Ysj54s8BP6XGkq9hEJ6G4yxgyV+BR
17 | DUOs5X8/TLT8POuIMYvKTQthQyCk0eLv2FLdESDuuKx0kBVY3s8lK3/z5HhrdOiN
18 | VMNZU+xDKgKc3hN9ypkk8vcZe6EtH7Y14e0rVcsCgYBTgxi8F/M5K0wG9rAqphNz
19 | VFBA9XKn/2M33cKjO5X5tXIEKzpAjaUQvNxexG04rJGljzG8+mar0M6ONahw5yD1
20 | O7i/XWgazgpuOEkkVYiYbd8RutfDgR4vFVMn3hAP3eDnRtBplRWH9Ec3HTiNIys6
21 | F8PKBOQjyRZQQC7jyzW3hQKBgACe5HeuFwXLSOYsb6mLmhR+6+VPT4wR1F95W27N
22 | USk9jyxAnngxfpmTkiziABdgS9N+pfr5cyN4BP77ia/Jn6kzkC5Cl9SN5KdIkA3z
23 | vPVtN/x/ThuQU5zaymmig1ThGLtMYggYOslG4LDfLPxY5YKIhle+Y+259twdr2yf
24 | Mf2dAoGAaGv3tWMgnIdGRk6EQL/yb9PKHo7ShN+tKNlGaK7WwzBdKs+Fe8jkgcr7
25 | pz4Ne887CmxejdISzOCcdT+Zm9Bx6I/uZwWOtDvWpIgIxVX9a9URj/+D1MxTE/y4
26 | d6H+c89yDY62I2+drMpdjCd3EtCaTlxpTbRS+s1eAHMH7aEkcCE=
27 | -----END RSA PRIVATE KEY-----
28 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/peering1.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Broker peering simulation (part 1).
 3 | //  Prototypes the state flow
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"os"
14 | 	"time"
15 | )
16 | 
17 | func main() {
18 | 	//  First argument is this broker's name
19 | 	//  Other arguments are our peers' names
20 | 	//
21 | 	if len(os.Args) < 2 {
22 | 		fmt.Println("syntax: peering1 me {you}...")
23 | 		os.Exit(1)
24 | 	}
25 | 	self := os.Args[1]
26 | 	fmt.Printf("I: preparing broker at %s...\n", self)
27 | 	rand.Seed(time.Now().UnixNano())
28 | 
29 | 	//  Bind state backend to endpoint
30 | 	statebe, _ := zmq.NewSocket(zmq.PUB)
31 | 	defer statebe.Close()
32 | 	statebe.Bind("ipc://" + self + "-state.ipc")
33 | 
34 | 	//  Connect statefe to all peers
35 | 	statefe, _ := zmq.NewSocket(zmq.SUB)
36 | 	defer statefe.Close()
37 | 	statefe.SetSubscribe("")
38 | 	for _, peer := range os.Args[2:] {
39 | 		fmt.Printf("I: connecting to state backend at '%s'\n", peer)
40 | 		statefe.Connect("ipc://" + peer + "-state.ipc")
41 | 	}
42 | 
43 | 	//  The main loop sends out status messages to peers, and collects
44 | 	//  status messages back from peers. The zmq_poll timeout defines
45 | 	//  our own heartbeat:
46 | 
47 | 	poller := zmq.NewPoller()
48 | 	poller.Add(statefe, zmq.POLLIN)
49 | 	for {
50 | 		//  Poll for activity, or 1 second timeout
51 | 		sockets, err := poller.Poll(time.Second)
52 | 		if err != nil {
53 | 			break
54 | 		}
55 | 
56 | 		//  Handle incoming status messages
57 | 		if len(sockets) == 1 {
58 | 			msg, _ := statefe.RecvMessage(0)
59 | 			peer_name := msg[0]
60 | 			available := msg[1]
61 | 			fmt.Printf("%s - %s workers free\n", peer_name, available)
62 | 		} else {
63 | 			statebe.SendMessage(self, rand.Intn(10))
64 | 		}
65 | 	}
66 | }
67 | 


--------------------------------------------------------------------------------
/website/www/src/css/tweetmap.less:
--------------------------------------------------------------------------------
  1 | html, body {
  2 |     width: 100%;
  3 |     height: 100%;
  4 |     margin: 0px;
  5 |     padding: 25px 0px 0px 0px;
  6 | }
  7 | 
  8 | .emoji {
  9 | 	margin: auto 2px auto 2px;
 10 | }
 11 | 
 12 | .container-fluid, .row {
 13 | 	height: 100%;
 14 | }
 15 | 
 16 | .pic {
 17 | 	margin-bottom: 15px;
 18 | 	cursor: pointer;
 19 | }
 20 | 
 21 | .navbar-brand {
 22 | 	font-family: 'Nova Square', cursive;
 23 | }
 24 | 
 25 | .list-group-item {
 26 | 	cursor: pointer;
 27 | 	color: @gray-dark;
 28 | }
 29 | 
 30 | .list-group-item > a {
 31 | 	color: @brand-primary;
 32 | }
 33 | 
 34 | #left-sidebar {
 35 | 	height: 100%;
 36 | 	border-right: 10px solid darken(@body-bg, 10%);
 37 | 	padding: 5px;
 38 | }
 39 | 
 40 | #left-sidebar .nav > li > a {
 41 | 	padding: 8px 5px;
 42 | }
 43 | 
 44 | #map-container {
 45 | 	height: 100%;
 46 | 	background-color: #555555;
 47 |     z-index: 1;
 48 |     padding: 0px;
 49 | }
 50 | 
 51 | #map {
 52 |     height: 100%;
 53 | }
 54 | 
 55 | #tabs {
 56 | 	height: 100%;
 57 | }
 58 | 
 59 | .nav-tabs > li > a {
 60 | 	color: @text-muted;
 61 | 	font-family: 'Nova Square', cursive;
 62 | }
 63 | 
 64 | .nav-tabs > li > a:hover {
 65 | 	color: lighten(@body-bg, 10%);
 66 | 	font-family: 'Nova Square', cursive;
 67 | }
 68 | 
 69 | .nav-tabs > li.active > a, .nav-tabs > li.active > a:focus, .nav-tabs > li.active > a:hover {
 70 | 	color: #FFF;
 71 | }
 72 | 
 73 | .tab-pane {
 74 | 	margin-top: 5px;
 75 | }
 76 | 
 77 | #tab-content {
 78 | 	overflow-y: auto;
 79 | }
 80 | 
 81 | .list-group-item {
 82 | 	margin-top: 10px;
 83 | 	border-radius: 0px;
 84 | }
 85 | 
 86 | #alerts {
 87 | 	position: absolute;
 88 | 	z-index: 1;
 89 | 	bottom: 0px;
 90 | 	width: 50%;
 91 | 	left: 25%;
 92 | }
 93 | 
 94 | @media (max-width: @screen-xs-max) {
 95 | 	#alerts {
 96 | 		width: 80%;
 97 | 		left: 10%;
 98 | 	}
 99 | }
100 | 


--------------------------------------------------------------------------------
/lib/example/publisher.go:
--------------------------------------------------------------------------------
 1 | // Package main provides ...
 2 | package main
 3 | 
 4 | import (
 5 | 	"github.com/cdn-madness/tweetmap/lib"
 6 | 	"github.com/cdn-madness/tweetmap/protobuf"
 7 | 	"github.com/darkhelmet/twitterstream"
 8 | 	"log"
 9 | 	"time"
10 | )
11 | 
12 | const CONNSTR string = "tcp://127.0.0.1:7654"
13 | 
14 | func main() {
15 | 	// Create a twitterstream tweet
16 | 	inTweet := new(twitterstream.Tweet)
17 | 
18 | 	inTweet.Id = 200976524
19 | 
20 | 	inTweet.Coordinates = &twitterstream.Point{
21 | 		Lat:  11.1,
22 | 		Long: 11.1,
23 | 	}
24 | 
25 | 	inTweet.User = twitterstream.User{
26 | 		Id:         987654321,
27 | 		ScreenName: "alexanderurq",
28 | 	}
29 | 
30 | 	inTweet.Text = "This is a test tweet"
31 | 
32 | 	inTweet.Entities.Hashtags = append(inTweet.Entities.Hashtags, twitterstream.Hashtag{
33 | 		Text: "tweetmap",
34 | 	})
35 | 
36 | 	inTweet.Entities.Media = append(inTweet.Entities.Media, twitterstream.Medium{
37 | 		MediaUrl: "http://test.com",
38 | 	})
39 | 
40 | 	inTweet.Entities.Mentions = append(inTweet.Entities.Mentions, twitterstream.Mention{
41 | 		Id:         987654321,
42 | 		ScreenName: "golang",
43 | 	})
44 | 
45 | 	inTweet.Entities.Urls = append(inTweet.Entities.Urls, twitterstream.Url{
46 | 		DisplayUrl: "http://test.com",
47 | 		Url:        "http://test.com",
48 | 	})
49 | 
50 | 	// Transform the tweet
51 | 	var protoTweet = new(prototweet.Tweet)
52 | 	protoTweet = tweetmap.ToProtoTweet(inTweet)
53 | 
54 | 	tweetChan := make(chan *prototweet.Tweet)
55 | 	errorChan := make(chan error)
56 | 
57 | 	tweetmap.InitPublisher(CONNSTR, tweetChan, errorChan)
58 | 
59 | 	for i := 0; i < 1000; {
60 | 		select {
61 | 		case err := <-errorChan:
62 | 			log.Println(err.Error())
63 | 			i = 10
64 | 		case <-time.After(250 * time.Millisecond):
65 | 			log.Printf("Sent tweet %s", i)
66 | 			tweetChan <- protoTweet
67 | 			i++
68 | 		}
69 | 	}
70 | 	close(tweetChan)
71 | }
72 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/lvcache.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Last value cache
 3 | //  Uses XPUB subscription messages to re-send data
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"time"
13 | )
14 | 
15 | func main() {
16 | 	frontend, _ := zmq.NewSocket(zmq.SUB)
17 | 	frontend.Bind("tcp://*:5557")
18 | 	backend, _ := zmq.NewSocket(zmq.XPUB)
19 | 	backend.Bind("tcp://*:5558")
20 | 
21 | 	//  Subscribe to every single topic from publisher
22 | 	frontend.SetSubscribe("")
23 | 
24 | 	//  Store last instance of each topic in a cache
25 | 	cache := make(map[string]string)
26 | 
27 | 	//  We route topic updates from frontend to backend, and
28 | 	//  we handle subscriptions by sending whatever we cached,
29 | 	//  if anything:
30 | 	poller := zmq.NewPoller()
31 | 	poller.Add(frontend, zmq.POLLIN)
32 | 	poller.Add(backend, zmq.POLLIN)
33 | LOOP:
34 | 	for {
35 | 		polled, err := poller.Poll(1000 * time.Millisecond)
36 | 		if err != nil {
37 | 			break //  Interrupted
38 | 		}
39 | 
40 | 		for _, item := range polled {
41 | 			switch socket := item.Socket; socket {
42 | 			case frontend:
43 | 				//  Any new topic data we cache and then forward
44 | 				msg, err := frontend.RecvMessage(0)
45 | 				if err != nil {
46 | 					break LOOP
47 | 				}
48 | 				cache[msg[0]] = msg[1]
49 | 				backend.SendMessage(msg)
50 | 			case backend:
51 | 				//  When we get a new subscription we pull data from the cache:
52 | 				msg, err := backend.RecvMessage(0)
53 | 				if err != nil {
54 | 					break LOOP
55 | 				}
56 | 				frame := msg[0]
57 | 				//  Event is one byte 0=unsub or 1=sub, followed by topic
58 | 				if frame[0] == 1 {
59 | 					topic := frame[1:]
60 | 					fmt.Println("Sending cached topic", topic)
61 | 					previous, ok := cache[topic]
62 | 					if ok {
63 | 						backend.SendMessage(topic, previous)
64 | 					}
65 | 				}
66 | 			}
67 | 		}
68 | 	}
69 | }
70 | 


--------------------------------------------------------------------------------
/lib/transform_test.go:
--------------------------------------------------------------------------------
 1 | package tweetmap
 2 | 
 3 | import (
 4 | 	"github.com/cdn-madness/tweetmap/protobuf"
 5 | 	"github.com/darkhelmet/twitterstream"
 6 | 	"github.com/golang/protobuf/proto"
 7 | 	"github.com/stretchr/testify/assert"
 8 | 	"testing"
 9 | )
10 | 
11 | func TestToProtoTweet(t *testing.T) {
12 | 	// Create a twitterstream tweet
13 | 	inTweet := new(twitterstream.Tweet)
14 | 
15 | 	inTweet.Id = 200976524
16 | 
17 | 	inTweet.Coordinates = &twitterstream.Point{
18 | 		Lat:  11.1,
19 | 		Long: 11.1,
20 | 	}
21 | 
22 | 	inTweet.User = twitterstream.User{
23 | 		Id:         987654321,
24 | 		ScreenName: "alexanderurq",
25 | 	}
26 | 
27 | 	inTweet.Text = "This is a test tweet"
28 | 
29 | 	inTweet.Entities.Hashtags = append(inTweet.Entities.Hashtags, twitterstream.Hashtag{
30 | 		Text: "tweetmap",
31 | 	})
32 | 
33 | 	inTweet.Entities.Media = append(inTweet.Entities.Media, twitterstream.Medium{
34 | 		MediaUrl: "http://test.com",
35 | 	})
36 | 
37 | 	inTweet.Entities.Mentions = append(inTweet.Entities.Mentions, twitterstream.Mention{
38 | 		Id:         987654321,
39 | 		ScreenName: "golang",
40 | 	})
41 | 
42 | 	inTweet.Entities.Urls = append(inTweet.Entities.Urls, twitterstream.Url{
43 | 		DisplayUrl: "http://test.com",
44 | 		Url:        "http://test.com",
45 | 	})
46 | 
47 | 	// Transform the tweet
48 | 	var protoTweet = new(prototweet.Tweet)
49 | 	var err error
50 | 	protoTweet, err = ToProtoTweet(inTweet)
51 | 	assert.NoError(t, err)
52 | 
53 | 	// Malform the tweet
54 | 	inTweet.Coordinates = nil
55 | 	_, err = ToProtoTweet(inTweet)
56 | 	assert.Error(t, err)
57 | 
58 | 	// Marshall the tweet
59 | 	marshalled, err := proto.Marshal(protoTweet)
60 | 	assert.NoError(t, err)
61 | 	assert.NotNil(t, marshalled)
62 | 
63 | 	// Unmarshal the tweet
64 | 	var finalTweet = new(prototweet.Tweet)
65 | 	err = proto.Unmarshal(marshalled, finalTweet)
66 | 	assert.NoError(t, err)
67 | 
68 | 	// Compare the fields
69 | 	assert.True(t, assert.ObjectsAreEqual(protoTweet, finalTweet))
70 | }
71 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples_security/ironhouse.go:
--------------------------------------------------------------------------------
 1 | //  The Ironhouse Pattern
 2 | //
 3 | //  Security doesn't get any stronger than this. An attacker is going to
 4 | //  have to break into your systems to see data before/after encryption.
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"log"
13 | 	"runtime"
14 | )
15 | 
16 | func main() {
17 | 
18 | 	//  Start authentication engine
19 | 	zmq.AuthSetVerbose(true)
20 | 	zmq.AuthStart()
21 | 	zmq.AuthAllow("domain1", "127.0.0.1/8")
22 | 
23 | 	//  We need two certificates, one for the client and one for
24 | 	//  the server. The client must know the server's public key
25 | 	//  to make a CURVE connection.
26 | 	client_public, client_secret, err := zmq.NewCurveKeypair()
27 | 	checkErr(err)
28 | 	server_public, server_secret, err := zmq.NewCurveKeypair()
29 | 	checkErr(err)
30 | 
31 | 	//  Tell authenticator to use this public client key
32 | 	zmq.AuthCurveAdd("domain1", client_public)
33 | 
34 | 	//  Create and bind server socket
35 | 	server, _ := zmq.NewSocket(zmq.PUSH)
36 | 	server.ServerAuthCurve("domain1", server_secret)
37 | 	server.Bind("tcp://*:9000")
38 | 
39 | 	//  Create and connect client socket
40 | 	client, _ := zmq.NewSocket(zmq.PULL)
41 | 	client.ClientAuthCurve(server_public, client_public, client_secret)
42 | 	client.Connect("tcp://127.0.0.1:9000")
43 | 
44 | 	//  Send a single message from server to client
45 | 	_, err = server.Send("Hello", 0)
46 | 	checkErr(err)
47 | 	message, err := client.Recv(0)
48 | 	checkErr(err)
49 | 	if message != "Hello" {
50 | 		log.Fatalln(message, "!= Hello")
51 | 	}
52 | 
53 | 	zmq.AuthStop()
54 | 
55 | 	fmt.Println("Ironhouse test OK")
56 | 
57 | }
58 | 
59 | func checkErr(err error) {
60 | 	if err != nil {
61 | 		log.SetFlags(0)
62 | 		_, filename, lineno, ok := runtime.Caller(1)
63 | 		if ok {
64 | 			log.Fatalf("%v:%v: %v", filename, lineno, err)
65 | 		} else {
66 | 			log.Fatalln(err)
67 | 		}
68 | 	}
69 | }
70 | 


--------------------------------------------------------------------------------
/website/www/src/js/Tweet.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="lib/leaflet.d.ts"/>
 2 | 
 3 | enum MarkerType {
 4 | 	King,
 5 | 	Prince,
 6 | 	Plebian
 7 | };
 8 | 
 9 | interface ITweetData {
10 | 	id: string;
11 | 	author: string;
12 | 	text: string;
13 | 	latitude: number;
14 | 	longitude: number;
15 | 	hashtags?: string[];
16 | 	pictures?: string[];
17 | }
18 | 
19 | class Tweet {
20 | 	private _marker: L.Marker;
21 | 
22 | 	constructor(private data: ITweetData, private type: MarkerType = MarkerType.Plebian) {
23 | 		this.setupMarker();
24 | 	}
25 | 
26 | 	get marker(): L.Marker {
27 | 		return this._marker;
28 | 	}
29 | 
30 | 	get hashtags(): string[] {
31 | 		return this.data.hashtags;
32 | 	}
33 | 
34 | 	get pictures(): string[] {
35 | 		if (this.data.pictures) {
36 | 			return this.data.pictures;
37 | 		} else {
38 | 			return [];
39 | 		}
40 | 	}
41 | 
42 | 	get author(): string {
43 | 		return this.data.author;
44 | 	}
45 | 
46 | 	get text(): string {
47 | 		return this.data.text;
48 | 	}
49 | 
50 | 	getPopupText(): string {
51 | 		return '<a href="http://twitter.com/'
52 | 			 + this.data.author
53 | 			 + '" target="_blank">@'
54 | 			 + this.data.author
55 | 			 + ':</a> ' + this.data.text;
56 | 	}
57 | 
58 | 	setupMarker(): void {
59 | 		var settings: L.AwesomeMarker = {};
60 | 		settings.prefix = 'fa';
61 | 
62 | 		// Setup marker based on type
63 | 		switch (this.type) {
64 | 			case MarkerType.King:
65 | 					settings.icon = 'star';
66 | 					settings.markerColor = 'orange';
67 | 				break;
68 | 			default:
69 | 				settings.icon = 'twitter';
70 | 				settings.markerColor = 'cadetblue';
71 | 				break;
72 | 		}
73 | 
74 | 		// Create the popup
75 | 		var popup: L.Popup = L.popup().setContent(this.getPopupText());
76 | 
77 | 		// Create the marker
78 | 		var icon: L.Icon = L.AwesomeMarkers.icon(settings);
79 | 		var latLng: L.LatLng = new L.LatLng(this.data.latitude, this.data.longitude);
80 | 		this._marker = L.marker(latLng, { icon: icon }).bindPopup(popup, { autopan: false });
81 | 	}
82 | }
83 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/url.go:
--------------------------------------------------------------------------------
 1 | package pq
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	nurl "net/url"
 6 | 	"sort"
 7 | 	"strings"
 8 | )
 9 | 
10 | // ParseURL no longer needs to be used by clients of this library since supplying a URL as a
11 | // connection string to sql.Open() is now supported:
12 | //
13 | //	sql.Open("postgres", "postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full")
14 | //
15 | // It remains exported here for backwards-compatibility.
16 | //
17 | // ParseURL converts a url to a connection string for driver.Open.
18 | // Example:
19 | //
20 | //	"postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full"
21 | //
22 | // converts to:
23 | //
24 | //	"user=bob password=secret host=1.2.3.4 port=5432 dbname=mydb sslmode=verify-full"
25 | //
26 | // A minimal example:
27 | //
28 | //	"postgres://"
29 | //
30 | // This will be blank, causing driver.Open to use all of the defaults
31 | func ParseURL(url string) (string, error) {
32 | 	u, err := nurl.Parse(url)
33 | 	if err != nil {
34 | 		return "", err
35 | 	}
36 | 
37 | 	if u.Scheme != "postgres" {
38 | 		return "", fmt.Errorf("invalid connection protocol: %s", u.Scheme)
39 | 	}
40 | 
41 | 	var kvs []string
42 | 	escaper := strings.NewReplacer(` `, `\ `, `'`, `\'`, `\`, `\\`)
43 | 	accrue := func(k, v string) {
44 | 		if v != "" {
45 | 			kvs = append(kvs, k+"="+escaper.Replace(v))
46 | 		}
47 | 	}
48 | 
49 | 	if u.User != nil {
50 | 		v := u.User.Username()
51 | 		accrue("user", v)
52 | 
53 | 		v, _ = u.User.Password()
54 | 		accrue("password", v)
55 | 	}
56 | 
57 | 	i := strings.Index(u.Host, ":")
58 | 	if i < 0 {
59 | 		accrue("host", u.Host)
60 | 	} else {
61 | 		accrue("host", u.Host[:i])
62 | 		accrue("port", u.Host[i+1:])
63 | 	}
64 | 
65 | 	if u.Path != "" {
66 | 		accrue("dbname", u.Path[1:])
67 | 	}
68 | 
69 | 	q := u.Query()
70 | 	for k := range q {
71 | 		accrue(k, q.Get(k))
72 | 	}
73 | 
74 | 	sort.Strings(kvs) // Makes testing easier (not a performance concern)
75 | 	return strings.Join(kvs, " "), nil
76 | }
77 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/golang/protobuf/proto/Makefile:
--------------------------------------------------------------------------------
 1 | # Go support for Protocol Buffers - Google's data interchange format
 2 | #
 3 | # Copyright 2010 The Go Authors.  All rights reserved.
 4 | # https://github.com/golang/protobuf
 5 | #
 6 | # Redistribution and use in source and binary forms, with or without
 7 | # modification, are permitted provided that the following conditions are
 8 | # met:
 9 | #
10 | #     * Redistributions of source code must retain the above copyright
11 | # notice, this list of conditions and the following disclaimer.
12 | #     * Redistributions in binary form must reproduce the above
13 | # copyright notice, this list of conditions and the following disclaimer
14 | # in the documentation and/or other materials provided with the
15 | # distribution.
16 | #     * Neither the name of Google Inc. nor the names of its
17 | # contributors may be used to endorse or promote products derived from
18 | # this software without specific prior written permission.
19 | #
20 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 | 
32 | install:
33 | 	go install
34 | 
35 | test: install generate-test-pbs
36 | 	go test
37 | 
38 | 
39 | generate-test-pbs:
40 | 	make install
41 | 	make -C testdata
42 | 	make -C proto3_proto
43 | 	make
44 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/garyburd/go-oauth/oauth/examples_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2013 Gary Burd
 2 | //
 3 | // Licensed under the Apache License, Version 2.0 (the "License"): you may
 4 | // not use this file except in compliance with the License. You may obtain
 5 | // a copy of the License at
 6 | //
 7 | //     http://www.apache.org/licenses/LICENSE-2.0
 8 | //
 9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 | // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 | // License for the specific language governing permissions and limitations
13 | // under the License.
14 | 
15 | package oauth_test
16 | 
17 | import (
18 | 	"github.com/garyburd/go-oauth/oauth"
19 | 	"net/http"
20 | 	"net/url"
21 | 	"strings"
22 | )
23 | 
24 | // This example shows how to sign a request when the URL Opaque field is used.
25 | // See the note at http://golang.org/pkg/net/url/#URL for information on the
26 | // use of the URL Opaque field.
27 | func ExampleClient_SetAuthorizationHeader(client *oauth.Client, credentials *oauth.Credentials) error {
28 | 	form := url.Values{"maxResults": {"100"}}
29 | 
30 | 	// The last element of path contains a "/".
31 | 	path := "/document/encoding%2gizp"
32 | 
33 | 	// Create the request with the temporary path "/".
34 | 	req, err := http.NewRequest("GET", "http://api.example.com/", strings.NewReader(form.Encode()))
35 | 	if err != nil {
36 | 		return err
37 | 	}
38 | 
39 | 	// Overwrite the temporary path with the actual request path.
40 | 	req.URL.Opaque = path
41 | 
42 | 	// Sign the request.
43 | 	if err := client.SetAuthorizationHeader(req.Header, credentials, "GET", req.URL, form); err != nil {
44 | 		return err
45 | 	}
46 | 
47 | 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
48 | 
49 | 	resp, err := http.DefaultClient.Do(req)
50 | 	if err != nil {
51 | 		return err
52 | 	}
53 | 	defer resp.Body.Close()
54 | 	// process the response
55 | 	return nil
56 | }
57 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | A Go interface to [ZeroMQ](http://www.zeromq.org/) version 4.
 3 | 
 4 | This requires ZeroMQ version 4.0.1 or above. To use CURVE security,
 5 | ZeroMQ must be installed with [libsodium](https://github.com/jedisct1/libsodium) enabled.
 6 | 
 7 | For ZeroMQ version 3, see: http://github.com/pebbe/zmq3
 8 | 
 9 | For ZeroMQ version 2, see: http://github.com/pebbe/zmq2
10 | 
11 | Including all examples of [ØMQ - The Guide](http://zguide.zeromq.org/page:all).
12 | 
13 | Keywords: zmq, zeromq, 0mq, networks, distributed computing, message passing, fanout, pubsub, pipeline, request-reply
14 | 
15 | ### See also
16 | 
17 |  * [goczmq](https://github.com/zeromq/goczmq) - A Go interface to CZMQ
18 | 
19 | ## Install
20 | 
21 |     go get github.com/pebbe/zmq4
22 | 
23 | ## Docs
24 | 
25 |  * [package help](http://godoc.org/github.com/pebbe/zmq4)
26 |  * [wiki](https://github.com/pebbe/zmq4/wiki)
27 | 
28 | ## API change
29 | 
30 | There has been an API change in commit
31 | 0bc5ab465849847b0556295d9a2023295c4d169e of 2014-06-27, 10:17:55 UTC
32 | in the functions `AuthAllow` and `AuthDeny`.
33 | 
34 | Old:
35 | 
36 |     func AuthAllow(addresses ...string)
37 |     func AuthDeny(addresses ...string)
38 | 
39 | New:
40 | 
41 |     func AuthAllow(domain string, addresses ...string)
42 |     func AuthDeny(domain string, addresses ...string)
43 | 
44 | If `domain` can be parsed as an IP address, it will be interpreted as
45 | such, and it and all remaining addresses are added to all domains.
46 | 
47 | So this should still work as before:
48 | 
49 |     zmq.AuthAllow("127.0.0.1", "123.123.123.123")
50 | 
51 | But this won't compile:
52 | 
53 |     a := []string{"127.0.0.1", "123.123.123.123"}
54 |     zmq.AuthAllow(a...)
55 | 
56 | And needs to be rewritten as:
57 | 
58 |     a := []string{"127.0.0.1", "123.123.123.123"}
59 |     zmq.AuthAllow("*", a...)
60 | 
61 | Furthermore, an address can now be a single IP address, as well as an IP
62 | address and mask in CIDR notation, e.g. "123.123.123.0/24".
63 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples_security/stonehouse.go:
--------------------------------------------------------------------------------
 1 | //  The Stonehouse Pattern
 2 | //
 3 | //  Where we allow any clients to connect, but we promise clients
 4 | //  that we are who we claim to be, and our conversations won't be
 5 | //  tampered with or modified, or spied on.
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"log"
14 | 	"runtime"
15 | )
16 | 
17 | func main() {
18 | 
19 | 	//  Start authentication engine
20 | 	zmq.AuthSetVerbose(true)
21 | 	zmq.AuthStart()
22 | 	zmq.AuthAllow("domain1", "127.0.0.1")
23 | 
24 | 	//  Tell the authenticator to allow any CURVE requests for this domain
25 | 	zmq.AuthCurveAdd("domain1", zmq.CURVE_ALLOW_ANY)
26 | 
27 | 	//  We need two certificates, one for the client and one for
28 | 	//  the server. The client must know the server's public key
29 | 	//  to make a CURVE connection.
30 | 	client_public, client_secret, err := zmq.NewCurveKeypair()
31 | 	checkErr(err)
32 | 	server_public, server_secret, err := zmq.NewCurveKeypair()
33 | 	checkErr(err)
34 | 
35 | 	//  Create and bind server socket
36 | 	server, _ := zmq.NewSocket(zmq.PUSH)
37 | 	server.ServerAuthCurve("domain1", server_secret)
38 | 	server.Bind("tcp://*:9000")
39 | 
40 | 	//  Create and connect client socket
41 | 	client, _ := zmq.NewSocket(zmq.PULL)
42 | 	client.ClientAuthCurve(server_public, client_public, client_secret)
43 | 	client.Connect("tcp://127.0.0.1:9000")
44 | 
45 | 	//  Send a single message from server to client
46 | 	_, err = server.Send("Hello", 0)
47 | 	checkErr(err)
48 | 	message, err := client.Recv(0)
49 | 	checkErr(err)
50 | 	if message != "Hello" {
51 | 		log.Fatalln(message, "!= Hello")
52 | 	}
53 | 
54 | 	zmq.AuthStop()
55 | 
56 | 	fmt.Println("Stonehouse test OK")
57 | 
58 | }
59 | 
60 | func checkErr(err error) {
61 | 	if err != nil {
62 | 		log.SetFlags(0)
63 | 		_, filename, lineno, ok := runtime.Caller(1)
64 | 		if ok {
65 | 			log.Fatalf("%v:%v: %v", filename, lineno, err)
66 | 		} else {
67 | 			log.Fatalln(err)
68 | 		}
69 | 	}
70 | }
71 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/rtreq.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  ROUTER-to-REQ example.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | 	"math/rand"
12 | 	"time"
13 | )
14 | 
15 | const (
16 | 	NBR_WORKERS = 10
17 | )
18 | 
19 | func worker_task() {
20 | 	worker, _ := zmq.NewSocket(zmq.REQ)
21 | 	defer worker.Close()
22 | 	set_id(worker)
23 | 	worker.Connect("tcp://localhost:5671")
24 | 
25 | 	total := 0
26 | 	for {
27 | 		//  Tell the broker we're ready for work
28 | 		worker.Send("Hi Boss", 0)
29 | 
30 | 		//  Get workload from broker, until finished
31 | 		workload, _ := worker.Recv(0)
32 | 		if workload == "Fired!" {
33 | 			fmt.Printf("Completed: %d tasks\n", total)
34 | 			break
35 | 		}
36 | 		total++
37 | 
38 | 		//  Do some random work
39 | 		time.Sleep(time.Duration(rand.Intn(500)+1) * time.Millisecond)
40 | 	}
41 | }
42 | 
43 | func main() {
44 | 	broker, _ := zmq.NewSocket(zmq.ROUTER)
45 | 	defer broker.Close()
46 | 
47 | 	broker.Bind("tcp://*:5671")
48 | 	rand.Seed(time.Now().UnixNano())
49 | 
50 | 	for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ {
51 | 		go worker_task()
52 | 	}
53 | 	//  Run for five seconds and then tell workers to end
54 | 	start_time := time.Now()
55 | 	workers_fired := 0
56 | 	for {
57 | 		//  Next message gives us least recently used worker
58 | 		identity, _ := broker.Recv(0)
59 | 		broker.Send(identity, zmq.SNDMORE)
60 | 		broker.Recv(0) //  Envelope delimiter
61 | 		broker.Recv(0) //  Response from worker
62 | 		broker.Send("", zmq.SNDMORE)
63 | 
64 | 		//  Encourage workers until it's time to fire them
65 | 		if time.Since(start_time) < 5*time.Second {
66 | 			broker.Send("Work harder", 0)
67 | 		} else {
68 | 			broker.Send("Fired!", 0)
69 | 			workers_fired++
70 | 			if workers_fired == NBR_WORKERS {
71 | 				break
72 | 			}
73 | 		}
74 | 	}
75 | 
76 | 	time.Sleep(time.Second)
77 | }
78 | 
79 | func set_id(soc *zmq.Socket) {
80 | 	identity := fmt.Sprintf("%04X-%04X", rand.Intn(0x10000), rand.Intn(0x10000))
81 | 	soc.SetIdentity(identity)
82 | }
83 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/golang/protobuf/proto/proto3_proto/Makefile:
--------------------------------------------------------------------------------
 1 | # Go support for Protocol Buffers - Google's data interchange format
 2 | #
 3 | # Copyright 2014 The Go Authors.  All rights reserved.
 4 | # https://github.com/golang/protobuf
 5 | #
 6 | # Redistribution and use in source and binary forms, with or without
 7 | # modification, are permitted provided that the following conditions are
 8 | # met:
 9 | #
10 | #     * Redistributions of source code must retain the above copyright
11 | # notice, this list of conditions and the following disclaimer.
12 | #     * Redistributions in binary form must reproduce the above
13 | # copyright notice, this list of conditions and the following disclaimer
14 | # in the documentation and/or other materials provided with the
15 | # distribution.
16 | #     * Neither the name of Google Inc. nor the names of its
17 | # contributors may be used to endorse or promote products derived from
18 | # this software without specific prior written permission.
19 | #
20 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 | 
32 | 
33 | include ../../Make.protobuf
34 | 
35 | all:	regenerate
36 | 
37 | regenerate:
38 | 	rm -f proto3.pb.go
39 | 	make proto3.pb.go
40 | 
41 | # The following rules are just aids to development. Not needed for typical testing.
42 | 
43 | diff:	regenerate
44 | 	git diff proto3.pb.go
45 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonecli2.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone client Model Two
 3 | //
 4 | //  In the original C example, the client misses updates between snapshot
 5 | //  and further updates. Sometimes, it even misses the END message of
 6 | //  the snapshot, so it waits for it forever.
 7 | //  This Go implementation has some modifications to improve this, but it
 8 | //  is still not fully reliable.
 9 | 
10 | package main
11 | 
12 | import (
13 | 	zmq "github.com/pebbe/zmq4"
14 | 	"github.com/pebbe/zmq4/examples/kvsimple"
15 | 
16 | 	"fmt"
17 | 	"time"
18 | )
19 | 
20 | func main() {
21 | 	snapshot, _ := zmq.NewSocket(zmq.DEALER)
22 | 	snapshot.Connect("tcp://localhost:5556")
23 | 
24 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
25 | 	subscriber.SetRcvhwm(100000) // or messages between snapshot and next are lost
26 | 	subscriber.SetSubscribe("")
27 | 	subscriber.Connect("tcp://localhost:5557")
28 | 
29 | 	time.Sleep(time.Second) // or messages between snapshot and next are lost
30 | 
31 | 	kvmap := make(map[string]*kvsimple.Kvmsg)
32 | 
33 | 	//  Get state snapshot
34 | 	sequence := int64(0)
35 | 	snapshot.SendMessage("ICANHAZ?")
36 | 	for {
37 | 		kvmsg, err := kvsimple.RecvKvmsg(snapshot)
38 | 		if err != nil {
39 | 			fmt.Println(err)
40 | 			break //  Interrupted
41 | 		}
42 | 		if key, _ := kvmsg.GetKey(); key == "KTHXBAI" {
43 | 			sequence, _ = kvmsg.GetSequence()
44 | 			fmt.Printf("Received snapshot=%d\n", sequence)
45 | 			break //  Done
46 | 		}
47 | 		kvmsg.Store(kvmap)
48 | 	}
49 | 	snapshot.Close()
50 | 
51 | 	first := true
52 | 	//  Now apply pending updates, discard out-of-sequence messages
53 | 	for {
54 | 		kvmsg, err := kvsimple.RecvKvmsg(subscriber)
55 | 		if err != nil {
56 | 			fmt.Println(err)
57 | 			break //  Interrupted
58 | 		}
59 | 		if seq, _ := kvmsg.GetSequence(); seq > sequence {
60 | 			sequence, _ = kvmsg.GetSequence()
61 | 			kvmsg.Store(kvmap)
62 | 			if first {
63 | 				// Show what the first regular update is after the snapshot,
64 | 				// to see if we missed updates.
65 | 				first = false
66 | 				fmt.Println("Next:", sequence)
67 | 			}
68 | 		}
69 | 	}
70 | }
71 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Build Status](https://travis-ci.org/cdn-madness/tweetmap.svg)](https://travis-ci.org/cdn-madness/tweetmap) [![Coverage Status](https://coveralls.io/repos/cdn-madness/tweetmap/badge.svg)](https://coveralls.io/r/cdn-madness/tweetmap)
 2 | #TweetMap
 3 | **tweetmap** is a set of applications written Go, SQL, and HTML/CSS/TypeScript that I used to create the [Ottawa Tweet Mapper](http://tweet.alexurquhart.com). I have tried to follow the [microservices](http://microservices.io) pattern for this project as much as possible, and my end goal is having everything dockerized and capable of scaling up to many different monitoring areas, on many different machines.
 4 | 
 5 | ##How it works
 6 | A tweet makes its way into the system through the watcher application. The watcher listens to the twitter firehose and filters out non-geolocated tweets, and geolocated tweets that are not within the given bounding box. The tweet is inserted into the geodatabase, serialized into a protocol buffer, then broadcast via ZMQ to any listening applications to either be broadcast over websocket, or to be cached for display in the website.
 7 | 
 8 | ##Components
 9 | + **lib** - Written in Go, this library provides helper functions to serialize/deserialize tweets from the Twitter API stream.
10 | + **protobuf** - Protocol buffer type and helper functions.
11 | + **watcher** - Utilizes the library to listen to the Twitter firehose, filter out tweets, insert them into the geodatabase, and broadcast them over ZMQ.
12 | + **database** - Postgresql/PostGIS database used to store the tweets.
13 | + **feed** - Listens to the ZMQ feed, deserializes the tweets, and re-broadcasts them over a websocket. Keeps track of the number of connected users.
14 | + **website** - Serves the static website, as well as the JSON API for tweet statistics.
15 | 
16 | ##TODO List
17 | + Drop dependency on ZMQ to something pure Go
18 | + Drop dependency on protocol buffers
19 | + Fork the twitterstream repo and modify it to use channels/pipelining, and also save the extra step of serializing/deserializing to protocol buffers
20 | + Save URL's in the tweet database
21 | + Convert emoji's in the tweet text to images.
22 | 


--------------------------------------------------------------------------------
/lib/feed.go:
--------------------------------------------------------------------------------
 1 | package tweetmap
 2 | 
 3 | import (
 4 | 	"github.com/cdn-madness/tweetmap/protobuf"
 5 | 	"github.com/darkhelmet/twitterstream"
 6 | 	"time"
 7 | )
 8 | 
 9 | // Filter type
10 | // Functions take a tweet and return true if it should continue being processed
11 | type TweetFilter func(t *twitterstream.Tweet) bool
12 | 
13 | // API keys and extent bounding box coordinates
14 | type TwitterAPIConfig struct {
15 | 	ConsumerKey    string
16 | 	ConsumerSecret string
17 | 	AccessToken    string
18 | 	AccessSecret   string
19 | 	SouthEast      twitterstream.Point
20 | 	NorthWest      twitterstream.Point
21 | }
22 | 
23 | // Listens starts up the twitterstream
24 | // Takes a API configuration, a filter function, and a "done" channel
25 | // Returns a tweet channel, and an error channel
26 | func ListenToTwitter(cfg TwitterAPIConfig, filterFunc TweetFilter, doneChan chan bool) (chan *prototweet.Tweet, chan error) {
27 | 	tweetChan := make(chan *prototweet.Tweet)
28 | 	errorChan := make(chan error)
29 | 
30 | 	go func(cfg TwitterAPIConfig, filterFunc TweetFilter, doneChan chan bool, tweetChan chan *prototweet.Tweet, errorChan chan error) {
31 | 		client := twitterstream.NewClientTimeout(cfg.ConsumerKey, cfg.ConsumerSecret, cfg.AccessToken, cfg.AccessSecret, 2*time.Hour)
32 | 
33 | 		// Loop indefinitely
34 | 		// TODO - enable tracking to see how often connections are attempted
35 | 		for {
36 | 			// Request the stream
37 | 			stream, err := client.Locations(cfg.SouthEast, cfg.NorthWest)
38 | 
39 | 			// If no connection, then sleep for 30 seconds and try again
40 | 			if err != nil {
41 | 				errorChan <- err
42 | 				time.Sleep(30 * time.Second)
43 | 				continue
44 | 			}
45 | 
46 | 			for {
47 | 				tweet, err := stream.Next()
48 | 				if err != nil {
49 | 					errorChan <- err
50 | 					break
51 | 				}
52 | 
53 | 				// Filter tweeet and send it off
54 | 				if filterFunc(tweet) {
55 | 					if pTweet, err := ToProtoTweet(tweet); err != nil {
56 | 						errorChan <- err
57 | 					} else {
58 | 						tweetChan <- pTweet
59 | 					}
60 | 				}
61 | 			}
62 | 		}
63 | 	}(cfg, filterFunc, doneChan, tweetChan, errorChan)
64 | 
65 | 	return tweetChan, errorChan
66 | }
67 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/ticlient.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Titanic client example.
 3 | //  Implements client side of http://rfc.zeromq.org/spec:9
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	"github.com/pebbe/zmq4/examples/mdapi"
 9 | 
10 | 	"errors"
11 | 	"fmt"
12 | 	"os"
13 | 	"time"
14 | )
15 | 
16 | //  Calls a TSP service
17 | //  Returns response if successful (status code 200 OK), else NULL
18 | //
19 | func ServiceCall(session *mdapi.Mdcli, service string, request ...string) (reply []string, err error) {
20 | 	reply = []string{}
21 | 	msg, err := session.Send(service, request...)
22 | 	if err == nil {
23 | 		switch status := msg[0]; status {
24 | 		case "200":
25 | 			reply = msg[1:]
26 | 			return
27 | 		case "400":
28 | 			fmt.Println("E: client fatal error, aborting")
29 | 			os.Exit(1)
30 | 		case "500":
31 | 			fmt.Println("E: server fatal error, aborting")
32 | 			os.Exit(1)
33 | 		}
34 | 	} else {
35 | 		fmt.Println("E: " + err.Error())
36 | 		os.Exit(0)
37 | 	}
38 | 
39 | 	err = errors.New("Didn't succeed")
40 | 	return //  Didn't succeed, don't care why not
41 | }
42 | 
43 | //  The main task tests our service call by sending an echo request:
44 | 
45 | func main() {
46 | 	var verbose bool
47 | 	if len(os.Args) > 1 && os.Args[1] == "-v" {
48 | 		verbose = true
49 | 	}
50 | 	session, _ := mdapi.NewMdcli("tcp://localhost:5555", verbose)
51 | 
52 | 	//  1. Send 'echo' request to Titanic
53 | 	reply, err := ServiceCall(session, "titanic.request", "echo", "Hello world")
54 | 	if err != nil {
55 | 		fmt.Println(err)
56 | 		return
57 | 	}
58 | 
59 | 	var uuid string
60 | 	if err == nil {
61 | 		uuid = reply[0]
62 | 		fmt.Println("I: request UUID", uuid)
63 | 	}
64 | 
65 | 	time.Sleep(100 * time.Millisecond)
66 | 
67 | 	//  2. Wait until we get a reply
68 | 	for {
69 | 		reply, err := ServiceCall(session, "titanic.reply", uuid)
70 | 		if err == nil {
71 | 			fmt.Println("Reply:", reply[0])
72 | 
73 | 			//  3. Close request
74 | 			ServiceCall(session, "titanic.close", uuid)
75 | 			break
76 | 		} else {
77 | 			fmt.Println("I: no reply yet, trying again...")
78 | 			time.Sleep(5 * time.Second) //  Try again in 5 seconds
79 | 		}
80 | 	}
81 | }
82 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/rtdealer.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  ROUTER-to-DEALER example.
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | 	"math/rand"
12 | 	"time"
13 | )
14 | 
15 | const (
16 | 	NBR_WORKERS = 10
17 | )
18 | 
19 | func worker_task() {
20 | 	worker, _ := zmq.NewSocket(zmq.DEALER)
21 | 	defer worker.Close()
22 | 	set_id(worker) //  Set a printable identity
23 | 	worker.Connect("tcp://localhost:5671")
24 | 
25 | 	total := 0
26 | 	for {
27 | 		//  Tell the broker we're ready for work
28 | 		worker.Send("", zmq.SNDMORE)
29 | 		worker.Send("Hi Boss", 0)
30 | 
31 | 		//  Get workload from broker, until finished
32 | 		worker.Recv(0) //  Envelope delimiter
33 | 		workload, _ := worker.Recv(0)
34 | 		if workload == "Fired!" {
35 | 			fmt.Printf("Completed: %d tasks\n", total)
36 | 			break
37 | 		}
38 | 		total++
39 | 
40 | 		//  Do some random work
41 | 		time.Sleep(time.Duration(rand.Intn(500)+1) * time.Millisecond)
42 | 	}
43 | }
44 | 
45 | func main() {
46 | 	broker, _ := zmq.NewSocket(zmq.ROUTER)
47 | 	defer broker.Close()
48 | 
49 | 	broker.Bind("tcp://*:5671")
50 | 	rand.Seed(time.Now().UnixNano())
51 | 
52 | 	for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ {
53 | 		go worker_task()
54 | 	}
55 | 	//  Run for five seconds and then tell workers to end
56 | 	start_time := time.Now()
57 | 	workers_fired := 0
58 | 	for {
59 | 		//  Next message gives us least recently used worker
60 | 		identity, _ := broker.Recv(0)
61 | 		broker.Send(identity, zmq.SNDMORE)
62 | 		broker.Recv(0) //  Envelope delimiter
63 | 		broker.Recv(0) //  Response from worker
64 | 		broker.Send("", zmq.SNDMORE)
65 | 
66 | 		//  Encourage workers until it's time to fire them
67 | 		if time.Since(start_time) < 5*time.Second {
68 | 			broker.Send("Work harder", 0)
69 | 		} else {
70 | 			broker.Send("Fired!", 0)
71 | 			workers_fired++
72 | 			if workers_fired == NBR_WORKERS {
73 | 				break
74 | 			}
75 | 		}
76 | 	}
77 | 
78 | 	time.Sleep(time.Second)
79 | }
80 | 
81 | func set_id(soc *zmq.Socket) {
82 | 	identity := fmt.Sprintf("%04X-%04X", rand.Intn(0x10000), rand.Intn(0x10000))
83 | 	soc.SetIdentity(identity)
84 | }
85 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/golang/protobuf/proto/testdata/Makefile:
--------------------------------------------------------------------------------
 1 | # Go support for Protocol Buffers - Google's data interchange format
 2 | #
 3 | # Copyright 2010 The Go Authors.  All rights reserved.
 4 | # https://github.com/golang/protobuf
 5 | #
 6 | # Redistribution and use in source and binary forms, with or without
 7 | # modification, are permitted provided that the following conditions are
 8 | # met:
 9 | #
10 | #     * Redistributions of source code must retain the above copyright
11 | # notice, this list of conditions and the following disclaimer.
12 | #     * Redistributions in binary form must reproduce the above
13 | # copyright notice, this list of conditions and the following disclaimer
14 | # in the documentation and/or other materials provided with the
15 | # distribution.
16 | #     * Neither the name of Google Inc. nor the names of its
17 | # contributors may be used to endorse or promote products derived from
18 | # this software without specific prior written permission.
19 | #
20 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 | 
32 | 
33 | include ../../Make.protobuf
34 | 
35 | all:	regenerate
36 | 
37 | regenerate:
38 | 	rm -f test.pb.go
39 | 	make test.pb.go
40 | 
41 | # The following rules are just aids to development. Not needed for typical testing.
42 | 
43 | diff:	regenerate
44 | 	git diff test.pb.go
45 | 
46 | restore:
47 | 	cp test.pb.go.golden test.pb.go
48 | 
49 | preserve:
50 | 	cp test.pb.go test.pb.go.golden
51 | 


--------------------------------------------------------------------------------
/lib/transform.go:
--------------------------------------------------------------------------------
 1 | package tweetmap
 2 | 
 3 | import (
 4 | 	"github.com/cdn-madness/tweetmap/protobuf"
 5 | 	"github.com/darkhelmet/twitterstream"
 6 | 	"github.com/golang/protobuf/proto"
 7 | )
 8 | 
 9 | // Prototweet Error Type
10 | type ProtoTweetError struct{}
11 | 
12 | func (e *ProtoTweetError) Error() string {
13 | 	return "Could not transform tweet to protocol buffer"
14 | }
15 | 
16 | // Takes an input tweet from the twitterstream and transform it
17 | // into a prototweet - a type suitable for transmission over ZMQ
18 | // and JSON serialization
19 | func ToProtoTweet(in *twitterstream.Tweet) (out *prototweet.Tweet, err error) {
20 | 	defer func() {
21 | 		if r := recover(); r != nil {
22 | 			err = &ProtoTweetError{}
23 | 		}
24 | 	}()
25 | 
26 | 	// Create a new tweet
27 | 	tweet := &prototweet.Tweet{
28 | 		Id: proto.Int64(in.Id),
29 | 		User: &prototweet.Tweet_User{
30 | 			Id:   proto.Int64(in.User.Id),
31 | 			Name: proto.String(in.User.ScreenName),
32 | 		},
33 | 		Text: proto.String(in.Text),
34 | 		Coordinates: &prototweet.Tweet_Coordinate{
35 | 			Latitude:  proto.Float64(in.Coordinates.Lat.Float64()),
36 | 			Longitude: proto.Float64(in.Coordinates.Long.Float64()),
37 | 		},
38 | 	}
39 | 
40 | 	// Add the hashtags
41 | 	for _, v := range in.Entities.Hashtags {
42 | 		tweet.Hashtags = append(tweet.Hashtags, v.Text)
43 | 	}
44 | 
45 | 	// Add the pictures from twitter
46 | 	for _, v := range in.Entities.Media {
47 | 		pic := &prototweet.Tweet_Image{
48 | 			Source: proto.String("TWITTER"),
49 | 			Url:    proto.String(v.MediaUrl),
50 | 		}
51 | 		tweet.Pictures = append(tweet.Pictures, pic)
52 | 	}
53 | 
54 | 	// Add URL's
55 | 	for _, v := range in.Entities.Urls {
56 | 		// TODO: filter out instagram links and add them as pictures
57 | 		url := &prototweet.Tweet_Url{
58 | 			Actual:  proto.String(v.Url),
59 | 			Display: proto.String(v.DisplayUrl),
60 | 		}
61 | 		tweet.Urls = append(tweet.Urls, url)
62 | 	}
63 | 
64 | 	// Add mentions
65 | 	for _, v := range in.Entities.Mentions {
66 | 		mention := &prototweet.Tweet_User{
67 | 			Id:   proto.Int64(v.Id),
68 | 			Name: proto.String(v.FullName),
69 | 		}
70 | 		tweet.Mentions = append(tweet.Mentions, mention)
71 | 	}
72 | 
73 | 	out = tweet
74 | 	return
75 | }
76 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/suisnail.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Suicidal Snail
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | 	"log"
12 | 	"math/rand"
13 | 	"strconv"
14 | 	"time"
15 | )
16 | 
17 | //  This is our subscriber. It connects to the publisher and subscribes to
18 | //  everything. It sleeps for a short time between messages to simulate doing
19 | //  too much work. If a message is more than 1 second late, it croaks:
20 | 
21 | const (
22 | 	MAX_ALLOWED_DELAY = 1000 * time.Millisecond
23 | )
24 | 
25 | func subscriber(pipe chan<- string) {
26 | 	//  Subscribe to everything
27 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
28 | 	subscriber.SetSubscribe("")
29 | 	subscriber.Connect("tcp://localhost:5556")
30 | 	defer subscriber.Close()
31 | 
32 | 	//  Get and process messages
33 | 	for {
34 | 		msg, _ := subscriber.RecvMessage(0)
35 | 		i, _ := strconv.Atoi(msg[0])
36 | 		clock := time.Unix(int64(i), 0)
37 | 		fmt.Println(clock)
38 | 
39 | 		//  Suicide snail logic
40 | 		if time.Now().After(clock.Add(MAX_ALLOWED_DELAY)) {
41 | 			log.Println("E: subscriber cannot keep up, aborting")
42 | 			break
43 | 		}
44 | 		//  Work for 1 msec plus some random additional time
45 | 		time.Sleep(time.Duration(1 + rand.Intn(2)))
46 | 	}
47 | 	pipe <- "gone and died"
48 | }
49 | 
50 | //  This is our publisher task. It publishes a time-stamped message to its
51 | //  PUB socket every 1 msec:
52 | 
53 | func publisher(pipe <-chan string) {
54 | 	//  Prepare publisher
55 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
56 | 	publisher.Bind("tcp://*:5556")
57 | 	defer publisher.Close()
58 | 
59 | LOOP:
60 | 	for {
61 | 		//  Send current clock (msecs) to subscribers
62 | 		publisher.SendMessage(time.Now().Unix())
63 | 		select {
64 | 		case <-pipe:
65 | 			break LOOP
66 | 		default:
67 | 		}
68 | 		time.Sleep(time.Millisecond)
69 | 	}
70 | }
71 | 
72 | //  The main task simply starts a client, and a server, and then
73 | //  waits for the client to signal that it has died:
74 | 
75 | func main() {
76 | 	pubpipe := make(chan string)
77 | 	subpipe := make(chan string)
78 | 	go publisher(pubpipe)
79 | 	go subscriber(subpipe)
80 | 	<-subpipe
81 | 	pubpipe <- "break"
82 | 	time.Sleep(100 * time.Millisecond)
83 | }
84 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/flclient1.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Freelance client - Model 1.
 3 | //  Uses REQ socket to query one or more services
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"errors"
12 | 	"fmt"
13 | 	"os"
14 | 	"time"
15 | )
16 | 
17 | const (
18 | 	REQUEST_TIMEOUT = 1000 * time.Millisecond
19 | 	MAX_RETRIES     = 3 //  Before we abandon
20 | )
21 | 
22 | func try_request(endpoint string, request []string) (reply []string, err error) {
23 | 	fmt.Printf("I: trying echo service at %s...\n", endpoint)
24 | 	client, _ := zmq.NewSocket(zmq.REQ)
25 | 	client.Connect(endpoint)
26 | 
27 | 	//  Send request, wait safely for reply
28 | 	client.SendMessage(request)
29 | 	poller := zmq.NewPoller()
30 | 	poller.Add(client, zmq.POLLIN)
31 | 	polled, err := poller.Poll(REQUEST_TIMEOUT)
32 | 	reply = []string{}
33 | 	if len(polled) == 1 {
34 | 		reply, err = client.RecvMessage(0)
35 | 	} else {
36 | 		err = errors.New("Time out")
37 | 	}
38 | 	return
39 | }
40 | 
41 | //  The client uses a Lazy Pirate strategy if it only has one server to talk
42 | //  to. If it has 2 or more servers to talk to, it will try each server just
43 | //  once:
44 | 
45 | func main() {
46 | 	request := []string{"Hello world"}
47 | 	reply := []string{}
48 | 	var err error
49 | 
50 | 	endpoints := len(os.Args) - 1
51 | 	if endpoints == 0 {
52 | 		fmt.Printf("I: syntax: %s <endpoint> ...\n", os.Args[0])
53 | 	} else if endpoints == 1 {
54 | 		//  For one endpoint, we retry N times
55 | 		for retries := 0; retries < MAX_RETRIES; retries++ {
56 | 			endpoint := os.Args[1]
57 | 			reply, err = try_request(endpoint, request)
58 | 			if err == nil {
59 | 				break //  Successful
60 | 			}
61 | 			fmt.Printf("W: no response from %s, retrying...\n", endpoint)
62 | 		}
63 | 	} else {
64 | 		//  For multiple endpoints, try each at most once
65 | 		for endpoint_nbr := 0; endpoint_nbr < endpoints; endpoint_nbr++ {
66 | 			endpoint := os.Args[endpoint_nbr+1]
67 | 			reply, err = try_request(endpoint, request)
68 | 			if err == nil {
69 | 				break //  Successful
70 | 			}
71 | 			fmt.Println("W: no response from", endpoint)
72 | 		}
73 | 	}
74 | 	if len(reply) > 0 {
75 | 		fmt.Printf("Service is running OK: %q\n", reply)
76 | 	}
77 | }
78 | 


--------------------------------------------------------------------------------
/website/www/tslint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "rules": {
 3 |     "ban": false,
 4 |     "class-name": true,
 5 |     "comment-format": [true,
 6 |         "check-space"
 7 |     ],
 8 |     "curly": true,
 9 |     "eofline": true,
10 |     "forin": true,
11 |     "indent": [true, 4],
12 |     "interface-name": false,
13 |     "jsdoc-format": false,
14 |     "label-position": true,
15 |     "label-undefined": true,
16 |     "max-line-length": [true, 140],
17 |     "member-ordering": [true,
18 |         "public-before-private",
19 |         "static-before-instance",
20 |         "variables-before-functions"
21 |     ],
22 |     "no-arg": true,
23 |     "no-bitwise": true,
24 |     "no-construct": true,
25 |     "no-constructor-vars": false,
26 |     "no-debugger": true,
27 |     "no-duplicate-key": true,
28 |     "no-duplicate-variable": true,
29 |     "no-empty": true,
30 |     "no-eval": true,
31 |     "no-string-literal": true,
32 |     "no-switch-case-fall-through": true,
33 |     "no-trailing-comma": true,
34 |     "no-trailing-whitespace": true,
35 |     "no-unused-expression": true,
36 |     "no-unused-variable": true,
37 |     "no-unreachable": true,
38 |     "no-use-before-declare": true,
39 |     "no-var-requires": true,
40 |     "one-line": [true,
41 |         "check-open-brace",
42 |         "check-catch",
43 |         "check-else",
44 |         "check-whitespace"
45 |     ],
46 |     "quotemark": [true, "single"],
47 |     "radix": true,
48 |     "semicolon": true,
49 |     "triple-equals": [true, "allow-null-check"],
50 |     "typedef": [true,
51 |         "call-signature",
52 |         "parameter",
53 |         "property-declaration",
54 |         "variable-declaration",
55 |         "member-variable-declaration"
56 |     ],
57 |     "typedef-whitespace": [true, {
58 |         "call-signature": "nospace",
59 |         "index-signature": "nospace",
60 |         "parameter": "nospace",
61 |         "property-declaration": "nospace",
62 |         "variable-declaration": "nospace"
63 |     }],
64 |     "use-strict": [true,
65 |         "check-module"
66 |     ],
67 |     "variable-name": [true, "allow-leading-underscore"],
68 |     "whitespace": [true,
69 |         "check-branch",
70 |         "check-decl",
71 |         "check-operator",
72 |         "check-separator",
73 |         "check-type"
74 |     ]
75 |   }
76 | }
77 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/tripping.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Round-trip demonstrator.
 3 | //
 4 | //  While this example runs in a single process, that is just to make
 5 | //  it easier to start and stop the example. The client task signals to
 6 | //  main when it's ready.
 7 | //
 8 | 
 9 | package main
10 | 
11 | import (
12 | 	zmq "github.com/pebbe/zmq4"
13 | 
14 | 	"fmt"
15 | 	"time"
16 | )
17 | 
18 | func ClientTask(pipe chan<- bool) {
19 | 	client, _ := zmq.NewSocket(zmq.DEALER)
20 | 	client.Connect("tcp://localhost:5555")
21 | 	fmt.Println("Setting up test...")
22 | 	time.Sleep(100 * time.Millisecond)
23 | 
24 | 	fmt.Println("Synchronous round-trip test...")
25 | 	start := time.Now()
26 | 	var requests int
27 | 	for requests = 0; requests < 10000; requests++ {
28 | 		client.Send("hello", 0)
29 | 		client.Recv(0)
30 | 	}
31 | 	fmt.Println(requests, "calls in", time.Since(start))
32 | 
33 | 	fmt.Println("Asynchronous round-trip test...")
34 | 	start = time.Now()
35 | 	for requests = 0; requests < 100000; requests++ {
36 | 		client.Send("hello", 0)
37 | 	}
38 | 	for requests = 0; requests < 100000; requests++ {
39 | 		client.Recv(0)
40 | 	}
41 | 	fmt.Println(requests, "calls in", time.Since(start))
42 | 	pipe <- true
43 | }
44 | 
45 | //  Here is the worker task. All it does is receive a message, and
46 | //  bounce it back the way it came:
47 | 
48 | func WorkerTask() {
49 | 	worker, _ := zmq.NewSocket(zmq.DEALER)
50 | 	worker.Connect("tcp://localhost:5556")
51 | 
52 | 	for {
53 | 		msg, _ := worker.RecvMessage(0)
54 | 		worker.SendMessage(msg)
55 | 	}
56 | }
57 | 
58 | //  Here is the broker task. It uses the zmq_proxy function to switch
59 | //  messages between frontend and backend:
60 | 
61 | func BrokerTask() {
62 | 	//  Prepare our sockets
63 | 	frontend, _ := zmq.NewSocket(zmq.DEALER)
64 | 	frontend.Bind("tcp://*:5555")
65 | 	backend, _ := zmq.NewSocket(zmq.DEALER)
66 | 	backend.Bind("tcp://*:5556")
67 | 	zmq.Proxy(frontend, backend, nil)
68 | }
69 | 
70 | //  Finally, here's the main task, which starts the client, worker, and
71 | //  broker, and then runs until the client signals it to stop:
72 | 
73 | func main() {
74 | 	//  Create threads
75 | 	pipe := make(chan bool)
76 | 	go ClientTask(pipe)
77 | 	go WorkerTask()
78 | 	go BrokerTask()
79 | 
80 | 	//  Wait for signal on client pipe
81 | 	<-pipe
82 | }
83 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/golang/protobuf/proto/proto3_proto/proto3.proto:
--------------------------------------------------------------------------------
 1 | // Go support for Protocol Buffers - Google's data interchange format
 2 | //
 3 | // Copyright 2014 The Go Authors.  All rights reserved.
 4 | // https://github.com/golang/protobuf
 5 | //
 6 | // Redistribution and use in source and binary forms, with or without
 7 | // modification, are permitted provided that the following conditions are
 8 | // met:
 9 | //
10 | //     * Redistributions of source code must retain the above copyright
11 | // notice, this list of conditions and the following disclaimer.
12 | //     * Redistributions in binary form must reproduce the above
13 | // copyright notice, this list of conditions and the following disclaimer
14 | // in the documentation and/or other materials provided with the
15 | // distribution.
16 | //     * Neither the name of Google Inc. nor the names of its
17 | // contributors may be used to endorse or promote products derived from
18 | // this software without specific prior written permission.
19 | //
20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 | 
32 | syntax = "proto3";
33 | 
34 | package proto3_proto;
35 | 
36 | message Message {
37 |   enum Humour {
38 |     UNKNOWN = 0;
39 |     PUNS = 1;
40 |     SLAPSTICK = 2;
41 |     BILL_BAILEY = 3;
42 |   }
43 | 
44 |   string name = 1;
45 |   Humour hilarity = 2;
46 |   uint32 height_in_cm = 3;
47 |   bytes data = 4;
48 |   int64 result_count = 7;
49 |   bool true_scotsman = 8;
50 |   float score = 9;
51 | 
52 |   repeated uint64 key = 5;
53 |   Nested nested = 6;
54 | }
55 | 
56 | message Nested {
57 |   string bunny = 1;
58 | }
59 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/darkhelmet/twitterstream/coordinates.go:
--------------------------------------------------------------------------------
 1 | package twitterstream
 2 | 
 3 | import (
 4 |     "encoding/json"
 5 |     "errors"
 6 |     "fmt"
 7 | )
 8 | 
 9 | var (
10 |     MissingCoordinates = errors.New("Missing coordinates")
11 | )
12 | 
13 | type Latitude float64
14 | type Longitude float64
15 | 
16 | func (l Latitude) Float64() float64 {
17 |     return float64(l)
18 | }
19 | 
20 | func (l Longitude) Float64() float64 {
21 |     return float64(l)
22 | }
23 | 
24 | type Point struct {
25 |     Lat  Latitude
26 |     Long Longitude
27 | }
28 | 
29 | type rawPoint struct {
30 |     Points [2]float64 `json:"coordinates"`
31 |     Type   string     `json:"type"`
32 | }
33 | 
34 | func (c *Point) UnmarshalJSON(data []byte) error {
35 |     var rc rawPoint
36 |     err := json.Unmarshal(data, &rc)
37 |     if err != nil {
38 |         return err
39 |     }
40 |     c.Long = Longitude(rc.Points[0])
41 |     c.Lat = Latitude(rc.Points[1])
42 |     return nil
43 | }
44 | 
45 | func (c *Point) MarshalJSON() ([]byte, error) {
46 |     var rc rawPoint
47 |     rc.Type = "Point"
48 |     rc.Points[0] = float64(c.Long)
49 |     rc.Points[1] = float64(c.Lat)
50 |     return json.Marshal(rc)
51 | }
52 | 
53 | type Box struct {
54 |     Points []Point
55 | }
56 | 
57 | func (b *Box) UnmarshalJSON(data []byte) (err error) {
58 |     var v map[string]interface{}
59 |     err = json.Unmarshal(data, &v)
60 |     if err != nil {
61 |         return
62 |     }
63 | 
64 |     defer func() {
65 |         if r := recover(); r != nil {
66 |             err = fmt.Errorf("%s: failed decoding %T from %#v", r, b, string(data))
67 |         }
68 |     }()
69 | 
70 |     inner := v["coordinates"].([]interface{})[0].([]interface{})
71 |     for _, array := range inner {
72 |         pair := array.([]interface{})
73 |         point := Point{Latitude(pair[1].(float64)), Longitude(pair[0].(float64))}
74 |         b.Points = append(b.Points, point)
75 |     }
76 | 
77 |     return nil
78 | }
79 | 
80 | func (b *Box) MarshalJSON() ([]byte, error) {
81 |     coords := make([]interface{}, 0, len(b.Points))
82 |     for _, point := range b.Points {
83 |         coords = append(coords, []interface{}{point.Long, point.Lat})
84 |     }
85 |     v := map[string]interface{}{
86 |         "coordinates": []interface{}{coords},
87 |         "type":        "Polygon",
88 |     }
89 |     return json.Marshal(v)
90 | }
91 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonecli4.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone client Model Four
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/kvsimple"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"time"
14 | )
15 | 
16 | const (
17 | 	SUBTREE = "/client/"
18 | )
19 | 
20 | func main() {
21 | 	snapshot, _ := zmq.NewSocket(zmq.DEALER)
22 | 	snapshot.Connect("tcp://localhost:5556")
23 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
24 | 	subscriber.SetSubscribe(SUBTREE)
25 | 	subscriber.Connect("tcp://localhost:5557")
26 | 	publisher, _ := zmq.NewSocket(zmq.PUSH)
27 | 	publisher.Connect("tcp://localhost:5558")
28 | 
29 | 	kvmap := make(map[string]*kvsimple.Kvmsg)
30 | 	rand.Seed(time.Now().UnixNano())
31 | 
32 | 	//  We first request a state snapshot:
33 | 	sequence := int64(0)
34 | 	snapshot.SendMessage("ICANHAZ?", SUBTREE)
35 | 	for {
36 | 		kvmsg, err := kvsimple.RecvKvmsg(snapshot)
37 | 		if err != nil {
38 | 			break //  Interrupted
39 | 		}
40 | 		if key, _ := kvmsg.GetKey(); key == "KTHXBAI" {
41 | 			sequence, _ := kvmsg.GetSequence()
42 | 			fmt.Println("I: received snapshot =", sequence)
43 | 			break //  Done
44 | 		}
45 | 		kvmsg.Store(kvmap)
46 | 	}
47 | 	snapshot.Close()
48 | 
49 | 	poller := zmq.NewPoller()
50 | 	poller.Add(subscriber, zmq.POLLIN)
51 | 	alarm := time.Now().Add(1000 * time.Millisecond)
52 | 	for {
53 | 		tickless := alarm.Sub(time.Now())
54 | 		if tickless < 0 {
55 | 			tickless = 0
56 | 		}
57 | 		polled, err := poller.Poll(tickless)
58 | 		if err != nil {
59 | 			break //  Context has been shut down
60 | 		}
61 | 		if len(polled) == 1 {
62 | 			kvmsg, err := kvsimple.RecvKvmsg(subscriber)
63 | 			if err != nil {
64 | 				break //  Interrupted
65 | 			}
66 | 
67 | 			//  Discard out-of-sequence kvmsgs, incl. heartbeats
68 | 			if seq, _ := kvmsg.GetSequence(); seq > sequence {
69 | 				sequence = seq
70 | 				kvmsg.Store(kvmap)
71 | 				fmt.Println("I: received update =", sequence)
72 | 			}
73 | 		}
74 | 		//  If we timed-out, generate a random kvmsg
75 | 		if time.Now().After(alarm) {
76 | 			kvmsg := kvsimple.NewKvmsg(0)
77 | 			kvmsg.SetKey(fmt.Sprintf("%s%d", SUBTREE, rand.Intn(10000)))
78 | 			kvmsg.SetBody(fmt.Sprint(rand.Intn(1000000)))
79 | 			kvmsg.Send(publisher)
80 | 			alarm = time.Now().Add(1000 * time.Millisecond)
81 | 		}
82 | 	}
83 | 	fmt.Printf("Interrupted\n%d messages in\n", sequence)
84 | }
85 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonesrv3.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone server Model Three
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/kvsimple"
10 | 
11 | 	"fmt"
12 | 	"time"
13 | )
14 | 
15 | func main() {
16 | 	snapshot, _ := zmq.NewSocket(zmq.ROUTER)
17 | 	snapshot.Bind("tcp://*:5556")
18 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
19 | 	publisher.Bind("tcp://*:5557")
20 | 	collector, _ := zmq.NewSocket(zmq.PULL)
21 | 	collector.Bind("tcp://*:5558")
22 | 
23 | 	//  The body of the main task collects updates from clients and
24 | 	//  publishes them back out to clients:
25 | 
26 | 	sequence := int64(0)
27 | 	kvmap := make(map[string]*kvsimple.Kvmsg)
28 | 
29 | 	poller := zmq.NewPoller()
30 | 	poller.Add(collector, zmq.POLLIN)
31 | 	poller.Add(snapshot, zmq.POLLIN)
32 | LOOP:
33 | 	for {
34 | 		polled, err := poller.Poll(1000 * time.Millisecond)
35 | 		if err != nil {
36 | 			break
37 | 		}
38 | 		for _, item := range polled {
39 | 			switch socket := item.Socket; socket {
40 | 			case collector:
41 | 				//  Apply state update sent from client
42 | 				kvmsg, err := kvsimple.RecvKvmsg(collector)
43 | 				if err != nil {
44 | 					break LOOP //  Interrupted
45 | 				}
46 | 				sequence++
47 | 				kvmsg.SetSequence(sequence)
48 | 				kvmsg.Send(publisher)
49 | 				kvmsg.Store(kvmap)
50 | 				fmt.Println("I: publishing update", sequence)
51 | 			case snapshot:
52 | 				//  Execute state snapshot request
53 | 				msg, err := snapshot.RecvMessage(0)
54 | 				if err != nil {
55 | 					break LOOP
56 | 				}
57 | 				identity := msg[0]
58 | 
59 | 				//  Request is in second frame of message
60 | 				request := msg[1]
61 | 				if request != "ICANHAZ?" {
62 | 					fmt.Println("E: bad request, aborting")
63 | 					break LOOP
64 | 				}
65 | 				//  Send state snapshot to client
66 | 
67 | 				//  For each entry in kvmap, send kvmsg to client
68 | 				for _, kvmsg := range kvmap {
69 | 					snapshot.Send(identity, zmq.SNDMORE)
70 | 					kvmsg.Send(snapshot)
71 | 				}
72 | 
73 | 				//  Now send END message with sequence number
74 | 				fmt.Println("I: sending shapshot =", sequence)
75 | 				snapshot.Send(identity, zmq.SNDMORE)
76 | 				kvmsg := kvsimple.NewKvmsg(sequence)
77 | 				kvmsg.SetKey("KTHXBAI")
78 | 				kvmsg.SetBody("")
79 | 				kvmsg.Send(snapshot)
80 | 			}
81 | 		}
82 | 	}
83 | 	fmt.Printf("Interrupted\n%d messages handled\n", sequence)
84 | }
85 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonecli3.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone client Model Three
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/kvsimple"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"time"
14 | )
15 | 
16 | func main() {
17 | 	snapshot, _ := zmq.NewSocket(zmq.DEALER)
18 | 	snapshot.Connect("tcp://localhost:5556")
19 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
20 | 	subscriber.SetSubscribe("")
21 | 	subscriber.Connect("tcp://localhost:5557")
22 | 	publisher, _ := zmq.NewSocket(zmq.PUSH)
23 | 	publisher.Connect("tcp://localhost:5558")
24 | 
25 | 	kvmap := make(map[string]*kvsimple.Kvmsg)
26 | 	rand.Seed(time.Now().UnixNano())
27 | 
28 | 	//  We first request a state snapshot:
29 | 	sequence := int64(0)
30 | 	snapshot.SendMessage("ICANHAZ?")
31 | 	for {
32 | 		kvmsg, err := kvsimple.RecvKvmsg(snapshot)
33 | 		if err != nil {
34 | 			break //  Interrupted
35 | 		}
36 | 		if key, _ := kvmsg.GetKey(); key == "KTHXBAI" {
37 | 			sequence, _ := kvmsg.GetSequence()
38 | 			fmt.Println("I: received snapshot =", sequence)
39 | 			break //  Done
40 | 		}
41 | 		kvmsg.Store(kvmap)
42 | 	}
43 | 	snapshot.Close()
44 | 
45 | 	//  Now we wait for updates from the server, and every so often, we
46 | 	//  send a random key-value update to the server:
47 | 
48 | 	poller := zmq.NewPoller()
49 | 	poller.Add(subscriber, zmq.POLLIN)
50 | 	alarm := time.Now().Add(1000 * time.Millisecond)
51 | 	for {
52 | 		tickless := alarm.Sub(time.Now())
53 | 		if tickless < 0 {
54 | 			tickless = 0
55 | 		}
56 | 		polled, err := poller.Poll(tickless)
57 | 		if err != nil {
58 | 			break //  Context has been shut down
59 | 		}
60 | 		if len(polled) == 1 {
61 | 			kvmsg, err := kvsimple.RecvKvmsg(subscriber)
62 | 			if err != nil {
63 | 				break //  Interrupted
64 | 			}
65 | 
66 | 			//  Discard out-of-sequence kvmsgs, incl. heartbeats
67 | 			if seq, _ := kvmsg.GetSequence(); seq > sequence {
68 | 				sequence = seq
69 | 				kvmsg.Store(kvmap)
70 | 				fmt.Println("I: received update =", sequence)
71 | 			}
72 | 		}
73 | 		//  If we timed-out, generate a random kvmsg
74 | 		if time.Now().After(alarm) {
75 | 			kvmsg := kvsimple.NewKvmsg(0)
76 | 			kvmsg.SetKey(fmt.Sprint(rand.Intn(10000)))
77 | 			kvmsg.SetBody(fmt.Sprint(rand.Intn(1000000)))
78 | 			kvmsg.Send(publisher)
79 | 			alarm = time.Now().Add(1000 * time.Millisecond)
80 | 		}
81 | 	}
82 | 	fmt.Printf("Interrupted\n%d messages in\n", sequence)
83 | }
84 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonecli5.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone client Model Five
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/kvmsg"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"time"
14 | )
15 | 
16 | const (
17 | 	SUBTREE = "/client/"
18 | )
19 | 
20 | func main() {
21 | 	snapshot, _ := zmq.NewSocket(zmq.DEALER)
22 | 	snapshot.Connect("tcp://localhost:5556")
23 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
24 | 	subscriber.SetSubscribe(SUBTREE)
25 | 	subscriber.Connect("tcp://localhost:5557")
26 | 	publisher, _ := zmq.NewSocket(zmq.PUSH)
27 | 	publisher.Connect("tcp://localhost:5558")
28 | 
29 | 	kvmap := make(map[string]*kvmsg.Kvmsg)
30 | 	rand.Seed(time.Now().UnixNano())
31 | 
32 | 	//  We first request a state snapshot:
33 | 	sequence := int64(0)
34 | 	snapshot.SendMessage("ICANHAZ?", SUBTREE)
35 | 	for {
36 | 		kvmsg, err := kvmsg.RecvKvmsg(snapshot)
37 | 		if err != nil {
38 | 			break //  Interrupted
39 | 		}
40 | 		if key, _ := kvmsg.GetKey(); key == "KTHXBAI" {
41 | 			sequence, _ := kvmsg.GetSequence()
42 | 			fmt.Println("I: received snapshot =", sequence)
43 | 			break //  Done
44 | 		}
45 | 		kvmsg.Store(kvmap)
46 | 	}
47 | 	snapshot.Close()
48 | 
49 | 	poller := zmq.NewPoller()
50 | 	poller.Add(subscriber, zmq.POLLIN)
51 | 	alarm := time.Now().Add(1000 * time.Millisecond)
52 | 	for {
53 | 		tickless := alarm.Sub(time.Now())
54 | 		if tickless < 0 {
55 | 			tickless = 0
56 | 		}
57 | 		polled, err := poller.Poll(tickless)
58 | 		if err != nil {
59 | 			break //  Context has been shut down
60 | 		}
61 | 		if len(polled) == 1 {
62 | 			kvmsg, err := kvmsg.RecvKvmsg(subscriber)
63 | 			if err != nil {
64 | 				break //  Interrupted
65 | 			}
66 | 
67 | 			//  Discard out-of-sequence kvmsgs, incl. heartbeats
68 | 			if seq, _ := kvmsg.GetSequence(); seq > sequence {
69 | 				sequence = seq
70 | 				kvmsg.Store(kvmap)
71 | 				fmt.Println("I: received update =", sequence)
72 | 			}
73 | 		}
74 | 		//  If we timed-out, generate a random kvmsg
75 | 		if time.Now().After(alarm) {
76 | 			kvmsg := kvmsg.NewKvmsg(0)
77 | 			kvmsg.SetKey(fmt.Sprintf("%s%d", SUBTREE, rand.Intn(10000)))
78 | 			kvmsg.SetBody(fmt.Sprint(rand.Intn(1000000)))
79 | 			kvmsg.SetProp("ttl", fmt.Sprintf("%d", rand.Intn((30)))) // seconds
80 | 			kvmsg.Send(publisher)
81 | 			alarm = time.Now().Add(1000 * time.Millisecond)
82 | 		}
83 | 	}
84 | 	fmt.Printf("Interrupted\n%d messages in\n", sequence)
85 | }
86 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/fileio2.go:
--------------------------------------------------------------------------------
 1 | //  File Transfer model #2
 2 | //
 3 | //  In which the client requests each chunk individually, thus
 4 | //  eliminating server queue overflows, but at a cost in speed.
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"os"
13 | 	"strconv"
14 | )
15 | 
16 | const (
17 | 	CHUNK_SIZE = 250000
18 | )
19 | 
20 | func client_thread(pipe chan<- string) {
21 | 	dealer, _ := zmq.NewSocket(zmq.DEALER)
22 | 	dealer.Connect("tcp://127.0.0.1:6000")
23 | 
24 | 	total := 0  //  Total bytes received
25 | 	chunks := 0 //  Total chunks received
26 | 
27 | 	for {
28 | 		//  Ask for next chunk
29 | 		dealer.SendMessage("fetch", total, CHUNK_SIZE)
30 | 
31 | 		chunk, err := dealer.RecvBytes(0)
32 | 		if err != nil {
33 | 			break //  Shutting down, quit
34 | 		}
35 | 		chunks++
36 | 		size := len(chunk)
37 | 		total += size
38 | 		if size < CHUNK_SIZE {
39 | 			break //  Last chunk received; exit
40 | 		}
41 | 	}
42 | 	fmt.Printf("%v chunks received, %v bytes\n", chunks, total)
43 | 	pipe <- "OK"
44 | }
45 | 
46 | //  The server thread waits for a chunk request from a client,
47 | //  reads that chunk and sends it back to the client:
48 | 
49 | func server_thread() {
50 | 	file, err := os.Open("testdata")
51 | 	if err != nil {
52 | 		panic(err)
53 | 	}
54 | 
55 | 	router, _ := zmq.NewSocket(zmq.ROUTER)
56 | 	router.SetRcvhwm(1)
57 | 	router.SetSndhwm(1)
58 | 	router.Bind("tcp://*:6000")
59 | 	for {
60 | 		msg, err := router.RecvMessage(0)
61 | 		if err != nil {
62 | 			break //  Shutting down, quit
63 | 		}
64 | 		//  First frame in each message is the sender identity
65 | 		identity := msg[0]
66 | 
67 | 		//  Second frame is "fetch" command
68 | 		if msg[1] != "fetch" {
69 | 			panic("command != \"fetch\"")
70 | 		}
71 | 
72 | 		//  Third frame is chunk offset in file
73 | 		offset, _ := strconv.ParseInt(msg[2], 10, 64)
74 | 
75 | 		//  Fourth frame is maximum chunk size
76 | 		chunksz, _ := strconv.Atoi(msg[3])
77 | 
78 | 		//  Read chunk of data from file
79 | 		chunk := make([]byte, chunksz)
80 | 		n, _ := file.ReadAt(chunk, offset)
81 | 
82 | 		//  Send resulting chunk to client
83 | 		router.SendMessage(identity, chunk[:n])
84 | 	}
85 | 	file.Close()
86 | }
87 | 
88 | //  The main task is just the same as in the first model.
89 | 
90 | func main() {
91 | 	pipe := make(chan string)
92 | 
93 | 	//  Start child threads
94 | 	go server_thread()
95 | 	go client_thread(pipe)
96 | 	//  Loop until client tells us it's done
97 | 	<-pipe
98 | }
99 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/spqueue.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Simple Pirate broker.
 3 | //  This is identical to load-balancing pattern, with no reliability
 4 | //  mechanisms. It depends on the client for recovery. Runs forever.
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | )
12 | 
13 | const (
14 | 	WORKER_READY = "\001" //  Signals worker is ready
15 | )
16 | 
17 | func main() {
18 | 	frontend, _ := zmq.NewSocket(zmq.ROUTER)
19 | 	backend, _ := zmq.NewSocket(zmq.ROUTER)
20 | 	defer frontend.Close()
21 | 	defer backend.Close()
22 | 	frontend.Bind("tcp://*:5555") //  For clients
23 | 	backend.Bind("tcp://*:5556")  //  For workers
24 | 
25 | 	//  Queue of available workers
26 | 	workers := make([]string, 0)
27 | 
28 | 	poller1 := zmq.NewPoller()
29 | 	poller1.Add(backend, zmq.POLLIN)
30 | 	poller2 := zmq.NewPoller()
31 | 	poller2.Add(backend, zmq.POLLIN)
32 | 	poller2.Add(frontend, zmq.POLLIN)
33 | 
34 | 	//  The body of this example is exactly the same as lbbroker2.
35 | LOOP:
36 | 	for {
37 | 		//  Poll frontend only if we have available workers
38 | 		var sockets []zmq.Polled
39 | 		var err error
40 | 		if len(workers) > 0 {
41 | 			sockets, err = poller2.Poll(-1)
42 | 		} else {
43 | 			sockets, err = poller1.Poll(-1)
44 | 		}
45 | 		if err != nil {
46 | 			break //  Interrupted
47 | 		}
48 | 		for _, socket := range sockets {
49 | 			switch s := socket.Socket; s {
50 | 			case backend: //  Handle worker activity on backend
51 | 				//  Use worker identity for load-balancing
52 | 				msg, err := s.RecvMessage(0)
53 | 				if err != nil {
54 | 					break LOOP //  Interrupted
55 | 				}
56 | 				var identity string
57 | 				identity, msg = unwrap(msg)
58 | 				workers = append(workers, identity)
59 | 
60 | 				//  Forward message to client if it's not a READY
61 | 				if msg[0] != WORKER_READY {
62 | 					frontend.SendMessage(msg)
63 | 				}
64 | 
65 | 			case frontend:
66 | 				//  Get client request, route to first available worker
67 | 				msg, err := s.RecvMessage(0)
68 | 				if err == nil {
69 | 					backend.SendMessage(workers[0], "", msg)
70 | 					workers = workers[1:]
71 | 				}
72 | 			}
73 | 		}
74 | 	}
75 | }
76 | 
77 | //  Pops frame off front of message and returns it as 'head'
78 | //  If next frame is empty, pops that empty frame.
79 | //  Return remaining frames of message as 'tail'
80 | func unwrap(msg []string) (head string, tail []string) {
81 | 	head = msg[0]
82 | 	if len(msg) > 1 && msg[1] == "" {
83 | 		tail = msg[2:]
84 | 	} else {
85 | 		tail = msg[1:]
86 | 	}
87 | 	return
88 | }
89 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/errors.go:
--------------------------------------------------------------------------------
 1 | package zmq4
 2 | 
 3 | /*
 4 | #include <zmq.h>
 5 | */
 6 | import "C"
 7 | 
 8 | import (
 9 | 	"syscall"
10 | )
11 | 
12 | // An Errno is an unsigned number describing an error condition as returned by a call to ZeroMQ.
13 | // It implements the error interface.
14 | // The number is either a standard system error, or an error defined by the C library of ZeroMQ.
15 | type Errno uintptr
16 | 
17 | const (
18 | 	// Error conditions defined by the C library of ZeroMQ.
19 | 
20 | 	// On Windows platform some of the standard POSIX errnos are not defined.
21 | 	EADDRINUSE      = Errno(C.EADDRINUSE)
22 | 	EADDRNOTAVAIL   = Errno(C.EADDRNOTAVAIL)
23 | 	EAFNOSUPPORT    = Errno(C.EAFNOSUPPORT)
24 | 	ECONNABORTED    = Errno(C.ECONNABORTED)
25 | 	ECONNREFUSED    = Errno(C.ECONNREFUSED)
26 | 	ECONNRESET      = Errno(C.ECONNRESET)
27 | 	EHOSTUNREACH    = Errno(C.EHOSTUNREACH)
28 | 	EINPROGRESS     = Errno(C.EINPROGRESS)
29 | 	EMSGSIZE        = Errno(C.EMSGSIZE)
30 | 	ENETDOWN        = Errno(C.ENETDOWN)
31 | 	ENETRESET       = Errno(C.ENETRESET)
32 | 	ENETUNREACH     = Errno(C.ENETUNREACH)
33 | 	ENOBUFS         = Errno(C.ENOBUFS)
34 | 	ENOTCONN        = Errno(C.ENOTCONN)
35 | 	ENOTSOCK        = Errno(C.ENOTSOCK)
36 | 	ENOTSUP         = Errno(C.ENOTSUP)
37 | 	EPROTONOSUPPORT = Errno(C.EPROTONOSUPPORT)
38 | 	ETIMEDOUT       = Errno(C.ETIMEDOUT)
39 | 
40 | 	// Native 0MQ error codes.
41 | 	EFSM           = Errno(C.EFSM)
42 | 	EMTHREAD       = Errno(C.EMTHREAD)
43 | 	ENOCOMPATPROTO = Errno(C.ENOCOMPATPROTO)
44 | 	ETERM          = Errno(C.ETERM)
45 | )
46 | 
47 | func errget(err error) error {
48 | 	eno, ok := err.(syscall.Errno)
49 | 	if ok {
50 | 		return Errno(eno)
51 | 	}
52 | 	return err
53 | }
54 | 
55 | // Return Errno as string.
56 | func (errno Errno) Error() string {
57 | 	if errno >= C.ZMQ_HAUSNUMERO {
58 | 		return C.GoString(C.zmq_strerror(C.int(errno)))
59 | 	}
60 | 	return syscall.Errno(errno).Error()
61 | }
62 | 
63 | /*
64 | Convert error to Errno.
65 | 
66 | Example usage:
67 | 
68 |     switch AsErrno(err) {
69 | 
70 |     case zmq.Errno(syscall.EINTR):
71 |         // standard system error
72 | 
73 |         // call was interrupted
74 | 
75 |     case zmq.ETERM:
76 |         // error defined by ZeroMQ
77 | 
78 |         // context was terminated
79 | 
80 |     }
81 | 
82 | See also: examples/interrupt.go
83 | */
84 | func AsErrno(err error) Errno {
85 | 	if eno, ok := err.(Errno); ok {
86 | 		return eno
87 | 	}
88 | 	if eno, ok := err.(syscall.Errno); ok {
89 | 		return Errno(eno)
90 | 	}
91 | 	return Errno(0)
92 | }
93 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/espresso.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Espresso Pattern
 3 | //  This shows how to capture data using a pub-sub proxy
 4 | //
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"math/rand"
13 | 	"time"
14 | )
15 | 
16 | //  The subscriber thread requests messages starting with
17 | //  A and B, then reads and counts incoming messages.
18 | 
19 | func subscriber_thread() {
20 | 	//  Subscribe to "A" and "B"
21 | 	subscriber, _ := zmq.NewSocket(zmq.SUB)
22 | 	subscriber.Connect("tcp://localhost:6001")
23 | 	subscriber.SetSubscribe("A")
24 | 	subscriber.SetSubscribe("B")
25 | 	defer subscriber.Close() // cancel subscribe
26 | 
27 | 	for count := 0; count < 5; count++ {
28 | 		_, err := subscriber.RecvMessage(0)
29 | 		if err != nil {
30 | 			break //  Interrupted
31 | 		}
32 | 	}
33 | }
34 | 
35 | //  The publisher sends random messages starting with A-J:
36 | 
37 | func publisher_thread() {
38 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
39 | 	publisher.Bind("tcp://*:6000")
40 | 
41 | 	for {
42 | 		s := fmt.Sprintf("%c-%05d", rand.Intn(10)+'A', rand.Intn(100000))
43 | 		_, err := publisher.SendMessage(s)
44 | 		if err != nil {
45 | 			break //  Interrupted
46 | 		}
47 | 		time.Sleep(100 * time.Millisecond) //  Wait for 1/10th second
48 | 	}
49 | }
50 | 
51 | //  The listener receives all messages flowing through the proxy, on its
52 | //  pipe. In CZMQ, the pipe is a pair of ZMQ_PAIR sockets that connects
53 | //  attached child threads. In other languages your mileage may vary:
54 | 
55 | func listener_thread() {
56 | 	pipe, _ := zmq.NewSocket(zmq.PAIR)
57 | 	pipe.Bind("inproc://pipe")
58 | 
59 | 	//  Print everything that arrives on pipe
60 | 	for {
61 | 		msg, err := pipe.RecvMessage(0)
62 | 		if err != nil {
63 | 			break //  Interrupted
64 | 		}
65 | 		fmt.Printf("%q\n", msg)
66 | 	}
67 | }
68 | 
69 | //  The main task starts the subscriber and publisher, and then sets
70 | //  itself up as a listening proxy. The listener runs as a child thread:
71 | 
72 | func main() {
73 | 	//  Start child threads
74 | 	go publisher_thread()
75 | 	go subscriber_thread()
76 | 	go listener_thread()
77 | 
78 | 	time.Sleep(100 * time.Millisecond)
79 | 
80 | 	subscriber, _ := zmq.NewSocket(zmq.XSUB)
81 | 	subscriber.Connect("tcp://localhost:6000")
82 | 	publisher, _ := zmq.NewSocket(zmq.XPUB)
83 | 	publisher.Bind("tcp://*:6001")
84 | 	listener, _ := zmq.NewSocket(zmq.PAIR)
85 | 	listener.Connect("inproc://pipe")
86 | 	zmq.Proxy(subscriber, publisher, listener)
87 | 
88 | 	fmt.Println("interrupted")
89 | }
90 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/bstarcli.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Binary Star client proof-of-concept implementation. This client does no
 3 | //  real work; it just demonstrates the Binary Star failover model.
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 
10 | 	"fmt"
11 | 	"strconv"
12 | 	"time"
13 | )
14 | 
15 | const (
16 | 	REQUEST_TIMEOUT = 1000 * time.Millisecond //  msecs
17 | 	SETTLE_DELAY    = 2000 * time.Millisecond //  Before failing over
18 | )
19 | 
20 | func main() {
21 | 
22 | 	server := []string{"tcp://localhost:5001", "tcp://localhost:5002"}
23 | 	server_nbr := 0
24 | 
25 | 	fmt.Printf("I: connecting to server at %s...\n", server[server_nbr])
26 | 	client, _ := zmq.NewSocket(zmq.REQ)
27 | 	client.Connect(server[server_nbr])
28 | 
29 | 	poller := zmq.NewPoller()
30 | 	poller.Add(client, zmq.POLLIN)
31 | 
32 | 	sequence := 0
33 | LOOP:
34 | 	for {
35 | 		//  We send a request, then we work to get a reply
36 | 		sequence++
37 | 		client.SendMessage(sequence)
38 | 
39 | 		for expect_reply := true; expect_reply; {
40 | 			//  Poll socket for a reply, with timeout
41 | 			polled, err := poller.Poll(REQUEST_TIMEOUT)
42 | 			if err != nil {
43 | 				break LOOP //  Interrupted
44 | 			}
45 | 
46 | 			//  We use a Lazy Pirate strategy in the client. If there's no
47 | 			//  reply within our timeout, we close the socket and try again.
48 | 			//  In Binary Star, it's the client vote which decides which
49 | 			//  server is primary; the client must therefore try to connect
50 | 			//  to each server in turn:
51 | 
52 | 			if len(polled) == 1 {
53 | 				//  We got a reply from the server, must match sequence
54 | 				reply, _ := client.RecvMessage(0)
55 | 				seq, _ := strconv.Atoi(reply[0])
56 | 				if seq == sequence {
57 | 					fmt.Printf("I: server replied OK (%s)\n", reply[0])
58 | 					expect_reply = false
59 | 					time.Sleep(time.Second) //  One request per second
60 | 				} else {
61 | 					fmt.Printf("E: bad reply from server: %q\n", reply)
62 | 				}
63 | 
64 | 			} else {
65 | 				fmt.Println("W: no response from server, failing over")
66 | 
67 | 				//  Old socket is confused; close it and open a new one
68 | 				client.Close()
69 | 				server_nbr = 1 - server_nbr
70 | 				time.Sleep(SETTLE_DELAY)
71 | 				fmt.Printf("I: connecting to server at %s...\n", server[server_nbr])
72 | 				client, _ = zmq.NewSocket(zmq.REQ)
73 | 				client.Connect(server[server_nbr])
74 | 
75 | 				poller = zmq.NewPoller()
76 | 				poller.Add(client, zmq.POLLIN)
77 | 
78 | 				//  Send request again, on new socket
79 | 				client.SendMessage(sequence)
80 | 			}
81 | 		}
82 | 	}
83 | }
84 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/fileio1.go:
--------------------------------------------------------------------------------
 1 | //  File Transfer model #1
 2 | //  
 3 | //  In which the server sends the entire file to the client in
 4 | //  large chunks with no attempt at flow control.
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	zmq "github.com/pebbe/zmq4"
10 | 
11 | 	"fmt"
12 | 	"io"
13 | 	"os"
14 | )
15 | 
16 | const (
17 | 	CHUNK_SIZE = 250000
18 | )
19 | 
20 | func client_thread(pipe chan<- string) {
21 | 	dealer, _ := zmq.NewSocket(zmq.DEALER)
22 | 	dealer.Connect("tcp://127.0.0.1:6000")
23 | 
24 | 	dealer.Send("fetch", 0)
25 | 	total := 0  //  Total bytes received
26 | 	chunks := 0 //  Total chunks received
27 | 
28 | 	for {
29 | 		frame, err := dealer.RecvBytes(0)
30 | 		if err != nil {
31 | 			break //  Shutting down, quit
32 | 		}
33 | 		chunks++
34 | 		size := len(frame)
35 | 		total += size
36 | 		if size == 0 {
37 | 			break //  Whole file received
38 | 		}
39 | 	}
40 | 	fmt.Printf("%v chunks received, %v bytes\n", chunks, total)
41 | 	pipe <- "OK"
42 | }
43 | 
44 | //  The server thread reads the file from disk in chunks, and sends
45 | //  each chunk to the client as a separate message. We only have one
46 | //  test file, so open that once and then serve it out as needed:
47 | 
48 | func server_thread() {
49 | 	file, err := os.Open("testdata")
50 | 	if err != nil {
51 | 		panic(err)
52 | 	}
53 | 
54 | 	router, _ := zmq.NewSocket(zmq.ROUTER)
55 | 	//  Default HWM is 1000, which will drop messages here
56 | 	//  since we send more than 1,000 chunks of test data,
57 | 	//  so set an infinite HWM as a simple, stupid solution:
58 | 	router.SetRcvhwm(0)
59 | 	router.SetSndhwm(0)
60 | 	router.Bind("tcp://*:6000")
61 | 	for {
62 | 		//  First frame in each message is the sender identity
63 | 		identity, err := router.Recv(0)
64 | 		if err != nil {
65 | 			break //  Shutting down, quit
66 | 		}
67 | 
68 | 		//  Second frame is "fetch" command
69 | 		command, _ := router.Recv(0)
70 | 		if command != "fetch" {
71 | 			panic("command != \"fetch\"")
72 | 		}
73 | 
74 | 		chunk := make([]byte, CHUNK_SIZE)
75 | 		for {
76 | 			n, _ := io.ReadFull(file, chunk)
77 | 			router.SendMessage(identity, chunk[:n])
78 | 			if n == 0 {
79 | 				break //  Always end with a zero-size frame
80 | 			}
81 | 		}
82 | 	}
83 | 	file.Close()
84 | }
85 | 
86 | //  The main task starts the client and server threads; it's easier
87 | //  to test this as a single process with threads, than as multiple
88 | //  processes:
89 | 
90 | func main() {
91 | 	pipe := make(chan string)
92 | 
93 | 	//  Start child threads
94 | 	go server_thread()
95 | 	go client_thread(pipe)
96 | 	//  Loop until client tells us it's done
97 | 	<-pipe
98 | }
99 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/golang/protobuf/proto/size2_test.go:
--------------------------------------------------------------------------------
 1 | // Go support for Protocol Buffers - Google's data interchange format
 2 | //
 3 | // Copyright 2012 The Go Authors.  All rights reserved.
 4 | // https://github.com/golang/protobuf
 5 | //
 6 | // Redistribution and use in source and binary forms, with or without
 7 | // modification, are permitted provided that the following conditions are
 8 | // met:
 9 | //
10 | //     * Redistributions of source code must retain the above copyright
11 | // notice, this list of conditions and the following disclaimer.
12 | //     * Redistributions in binary form must reproduce the above
13 | // copyright notice, this list of conditions and the following disclaimer
14 | // in the documentation and/or other materials provided with the
15 | // distribution.
16 | //     * Neither the name of Google Inc. nor the names of its
17 | // contributors may be used to endorse or promote products derived from
18 | // this software without specific prior written permission.
19 | //
20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 | 
32 | package proto
33 | 
34 | import (
35 | 	"testing"
36 | )
37 | 
38 | // This is a separate file and package from size_test.go because that one uses
39 | // generated messages and thus may not be in package proto without having a circular
40 | // dependency, whereas this file tests unexported details of size.go.
41 | 
42 | func TestVarintSize(t *testing.T) {
43 | 	// Check the edge cases carefully.
44 | 	testCases := []struct {
45 | 		n    uint64
46 | 		size int
47 | 	}{
48 | 		{0, 1},
49 | 		{1, 1},
50 | 		{127, 1},
51 | 		{128, 2},
52 | 		{16383, 2},
53 | 		{16384, 3},
54 | 		{1<<63 - 1, 9},
55 | 		{1 << 63, 10},
56 | 	}
57 | 	for _, tc := range testCases {
58 | 		size := sizeVarint(tc.n)
59 | 		if size != tc.size {
60 | 			t.Errorf("sizeVarint(%d) = %d, want %d", tc.n, size, tc.size)
61 | 		}
62 | 	}
63 | }
64 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/clonesrv4.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Clone server Model Four
 3 | //
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	zmq "github.com/pebbe/zmq4"
 9 | 	"github.com/pebbe/zmq4/examples/kvsimple"
10 | 
11 | 	"fmt"
12 | 	"strings"
13 | 	"time"
14 | )
15 | 
16 | //  The main task is identical to clonesrv3 except for where it
17 | //  handles subtrees.
18 | 
19 | func main() {
20 | 	snapshot, _ := zmq.NewSocket(zmq.ROUTER)
21 | 	snapshot.Bind("tcp://*:5556")
22 | 	publisher, _ := zmq.NewSocket(zmq.PUB)
23 | 	publisher.Bind("tcp://*:5557")
24 | 	collector, _ := zmq.NewSocket(zmq.PULL)
25 | 	collector.Bind("tcp://*:5558")
26 | 
27 | 	//  The body of the main task collects updates from clients and
28 | 	//  publishes them back out to clients:
29 | 
30 | 	sequence := int64(0)
31 | 	kvmap := make(map[string]*kvsimple.Kvmsg)
32 | 
33 | 	poller := zmq.NewPoller()
34 | 	poller.Add(collector, zmq.POLLIN)
35 | 	poller.Add(snapshot, zmq.POLLIN)
36 | LOOP:
37 | 	for {
38 | 		polled, err := poller.Poll(1000 * time.Millisecond)
39 | 		if err != nil {
40 | 			break
41 | 		}
42 | 		for _, item := range polled {
43 | 			switch socket := item.Socket; socket {
44 | 			case collector:
45 | 				//  Apply state update sent from client
46 | 				kvmsg, err := kvsimple.RecvKvmsg(collector)
47 | 				if err != nil {
48 | 					break LOOP //  Interrupted
49 | 				}
50 | 				sequence++
51 | 				kvmsg.SetSequence(sequence)
52 | 				kvmsg.Send(publisher)
53 | 				kvmsg.Store(kvmap)
54 | 				fmt.Println("I: publishing update", sequence)
55 | 			case snapshot:
56 | 				//  Execute state snapshot request
57 | 				msg, err := snapshot.RecvMessage(0)
58 | 				if err != nil {
59 | 					break LOOP
60 | 				}
61 | 				identity := msg[0]
62 | 
63 | 				//  Request is in second frame of message
64 | 				request := msg[1]
65 | 				if request != "ICANHAZ?" {
66 | 					fmt.Println("E: bad request, aborting")
67 | 					break LOOP
68 | 				}
69 | 				subtree := msg[2]
70 | 				//  Send state snapshot to client
71 | 
72 | 				//  For each entry in kvmap, send kvmsg to client
73 | 				for _, kvmsg := range kvmap {
74 | 					if key, _ := kvmsg.GetKey(); strings.HasPrefix(key, subtree) {
75 | 						snapshot.Send(identity, zmq.SNDMORE)
76 | 						kvmsg.Send(snapshot)
77 | 					}
78 | 				}
79 | 
80 | 				//  Now send END message with sequence number
81 | 				fmt.Println("I: sending shapshot =", sequence)
82 | 				snapshot.Send(identity, zmq.SNDMORE)
83 | 				kvmsg := kvsimple.NewKvmsg(sequence)
84 | 				kvmsg.SetKey("KTHXBAI")
85 | 				kvmsg.SetBody(subtree)
86 | 				kvmsg.Send(snapshot)
87 | 			}
88 | 		}
89 | 	}
90 | 	fmt.Printf("Interrupted\n%d messages handled\n", sequence)
91 | }
92 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/lpclient.go:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Lazy Pirate client.
 3 | //  Use zmq_poll to do a safe request-reply
 4 | //  To run, start lpserver and then randomly kill/restart it
 5 | //
 6 | 
 7 | package main
 8 | 
 9 | import (
10 | 	zmq "github.com/pebbe/zmq4"
11 | 
12 | 	"fmt"
13 | 	"strconv"
14 | 	"time"
15 | )
16 | 
17 | const (
18 | 	REQUEST_TIMEOUT = 2500 * time.Millisecond //  msecs, (> 1000!)
19 | 	REQUEST_RETRIES = 3                       //  Before we abandon
20 | 	SERVER_ENDPOINT = "tcp://localhost:5555"
21 | )
22 | 
23 | func main() {
24 | 	fmt.Println("I: connecting to server...")
25 | 	client, err := zmq.NewSocket(zmq.REQ)
26 | 	if err != nil {
27 | 		panic(err)
28 | 	}
29 | 	client.Connect(SERVER_ENDPOINT)
30 | 
31 | 	poller := zmq.NewPoller()
32 | 	poller.Add(client, zmq.POLLIN)
33 | 
34 | 	sequence := 0
35 | 	retries_left := REQUEST_RETRIES
36 | 	for retries_left > 0 {
37 | 		//  We send a request, then we work to get a reply
38 | 		sequence++
39 | 		client.SendMessage(sequence)
40 | 
41 | 		for expect_reply := true; expect_reply; {
42 | 			//  Poll socket for a reply, with timeout
43 | 			sockets, err := poller.Poll(REQUEST_TIMEOUT)
44 | 			if err != nil {
45 | 				break //  Interrupted
46 | 			}
47 | 
48 | 			//  Here we process a server reply and exit our loop if the
49 | 			//  reply is valid. If we didn't a reply we close the client
50 | 			//  socket and resend the request. We try a number of times
51 | 			//  before finally abandoning:
52 | 
53 | 			if len(sockets) > 0 {
54 | 				//  We got a reply from the server, must match sequence
55 | 				reply, err := client.RecvMessage(0)
56 | 				if err != nil {
57 | 					break //  Interrupted
58 | 				}
59 | 				seq, _ := strconv.Atoi(reply[0])
60 | 				if seq == sequence {
61 | 					fmt.Printf("I: server replied OK (%s)\n", reply[0])
62 | 					retries_left = REQUEST_RETRIES
63 | 					expect_reply = false
64 | 				} else {
65 | 					fmt.Printf("E: malformed reply from server: %s\n", reply)
66 | 				}
67 | 			} else {
68 | 				retries_left--
69 | 				if retries_left == 0 {
70 | 					fmt.Println("E: server seems to be offline, abandoning")
71 | 					break
72 | 				} else {
73 | 					fmt.Println("W: no response from server, retrying...")
74 | 					//  Old socket is confused; close it and open a new one
75 | 					client.Close()
76 | 					client, _ = zmq.NewSocket(zmq.REQ)
77 | 					client.Connect(SERVER_ENDPOINT)
78 | 					// Recreate poller for new client
79 | 					poller = zmq.NewPoller()
80 | 					poller.Add(client, zmq.POLLIN)
81 | 					//  Send request again, on new socket
82 | 					client.SendMessage(sequence)
83 | 				}
84 | 			}
85 | 		}
86 | 	}
87 | 	client.Close()
88 | }
89 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/kvmsg/kvmsg_test.go:
--------------------------------------------------------------------------------
  1 | package kvmsg
  2 | 
  3 | import (
  4 | 	zmq "github.com/pebbe/zmq4"
  5 | 
  6 | 	"os"
  7 | 	"testing"
  8 | )
  9 | 
 10 | //  The test is the same as in kvsimple with added support
 11 | //  for the uuid and property features of kvmsg
 12 | 
 13 | func TestKvmsg(t *testing.T) {
 14 | 
 15 | 	//  Prepare our context and sockets
 16 | 	output, err := zmq.NewSocket(zmq.DEALER)
 17 | 	if err != nil {
 18 | 		t.Error(err)
 19 | 	}
 20 | 
 21 | 	err = output.Bind("ipc://kvmsg_selftest.ipc")
 22 | 	if err != nil {
 23 | 		t.Error(err)
 24 | 	}
 25 | 
 26 | 	input, err := zmq.NewSocket(zmq.DEALER)
 27 | 	if err != nil {
 28 | 		t.Error(err)
 29 | 	}
 30 | 
 31 | 	err = input.Connect("ipc://kvmsg_selftest.ipc")
 32 | 	if err != nil {
 33 | 		t.Error(err)
 34 | 	}
 35 | 
 36 | 	kvmap := make(map[string]*Kvmsg)
 37 | 
 38 | 	//  Test send and receive of simple message
 39 | 	kvmsg := NewKvmsg(1)
 40 | 	kvmsg.SetKey("key")
 41 | 	kvmsg.SetUuid()
 42 | 	kvmsg.SetBody("body")
 43 | 	kvmsg.Dump()
 44 | 	err = kvmsg.Send(output)
 45 | 
 46 | 	kvmsg.Store(kvmap)
 47 | 	if err != nil {
 48 | 		t.Error(err)
 49 | 	}
 50 | 
 51 | 	kvmsg, err = RecvKvmsg(input)
 52 | 	if err != nil {
 53 | 		t.Error(err)
 54 | 	}
 55 | 	kvmsg.Dump()
 56 | 	key, err := kvmsg.GetKey()
 57 | 	if err != nil {
 58 | 		t.Error(err)
 59 | 	}
 60 | 	if key != "key" {
 61 | 		t.Error("Expected \"key\", got \"" + key + "\"")
 62 | 	}
 63 | 	kvmsg.Store(kvmap)
 64 | 
 65 | 	//  Test send and receive of message with properties
 66 | 	kvmsg = NewKvmsg(2)
 67 | 	err = kvmsg.SetProp("prop1", "value1")
 68 | 	if err != nil {
 69 | 		t.Error(err)
 70 | 	}
 71 | 	kvmsg.SetProp("prop2", "value1")
 72 | 	kvmsg.SetProp("prop2", "value2")
 73 | 	kvmsg.SetKey("key")
 74 | 	kvmsg.SetUuid()
 75 | 	kvmsg.SetBody("body")
 76 | 	if val, err := kvmsg.GetProp("prop2"); err != nil || val != "value2" {
 77 | 		if err != nil {
 78 | 			t.Error(err)
 79 | 		}
 80 | 		t.Error("Expected \"prop2\" = \"value2\", got \"" + val + "\"")
 81 | 	}
 82 | 	kvmsg.Dump()
 83 | 	err = kvmsg.Send(output)
 84 | 
 85 | 	kvmsg, err = RecvKvmsg(input)
 86 | 	if err != nil {
 87 | 		t.Error(err)
 88 | 	}
 89 | 	kvmsg.Dump()
 90 | 	key, err = kvmsg.GetKey()
 91 | 	if err != nil {
 92 | 		t.Error(err)
 93 | 	}
 94 | 	if key != "key" {
 95 | 		t.Error("Expected \"key\", got \"" + key + "\"")
 96 | 	}
 97 | 	prop, err := kvmsg.GetProp("prop2")
 98 | 	if err != nil {
 99 | 		t.Error(err)
100 | 	}
101 | 	if prop != "value2" {
102 | 		t.Error("Expected property \"value2\", got \"" + key + "\"")
103 | 	}
104 | 
105 | 	input.Close()
106 | 	output.Close()
107 | 	os.Remove("kvmsg_selftest.ipc")
108 | }
109 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: go
 2 | addons:
 3 |     - postgresql: "9.3"
 4 | before_install:
 5 |     - wget https://protobuf.googlecode.com/svn/rc/protobuf-2.6.0.tar.gz
 6 |     - wget http://download.zeromq.org/zeromq-4.0.5.tar.gz
 7 |     - wget http://nodejs.org/dist/v0.12.0/node-v0.12.0-linux-x64.tar.gz
 8 |     - tar -xzvf zeromq-4.0.5.tar.gz
 9 |     - tar -xzvf protobuf-2.6.0.tar.gz
10 | 
11 |     - go get github.com/tools/godep
12 |     - go get golang.org/x/tools/cmd/cover
13 |     - go get github.com/mattn/goveralls
14 |     - mkdir dist
15 | install:
16 |     - sudo apt-get install -y uuid-dev
17 |     - cd protobuf-2.6.0 && ./configure --prefix=/usr && make && sudo make install && cd ..
18 |     - cd zeromq-4.0.5 && ./configure && make && sudo make install && sudo ldconfig && cd ..
19 |     
20 |     - mkdir node
21 |     - sudo tar -xzvf node-v0.12.0-linux-x64.tar.gz -C node/ --strip-components=1
22 |     - export PATH=$HOME/node/bin:$PATH
23 |     - export NODE_PATH=$HOME/node/lib/node_modules
24 |     
25 |     - cd lib && godep restore && cd ..
26 |     - cd website/www && sudo npm install -g grunt-cli && npm install && cd ..
27 |     - psql -U postgres < database/schema.sql
28 | script:
29 |     - go test -v -covermode=count -coverprofile=c.out github.com/cdn-madness/tweetmap/lib
30 |     - cd feed && go build -v && cd ..
31 |     - cd website && go build -v
32 |     - cd www && grunt
33 | after_success:
34 |     - goveralls -coverprofile=c.out -service=travis-ci -repotoken $COVERALLS_TOKEN
35 |     - mv feed/feed dist/ && mv website/website dist/ && mv website/www/dist dist/ -r
36 |     - tar czf tweetmap.tar.gz dist/*
37 | env:
38 |   global:
39 |   - secure: tUfvi7QUyZqMTxqGaNofwOmCONOzz4QRubz+WJPxgd5L3NhCXYmeVQ5wdfGwZadJ3/Z0NWVlquLFcwL/O2lZy/qkk6e/yOtRnVQZMrz63Z+5O132RKznsIW9kQkzdElFkbEEG0coanSFi13yEz2KYwYhjqc6EhfXHCf5TURFIec=
40 |   - secure: G3MFtxmcefvRX9v7YikaS42jgZeEVxg22pF2VC14lmh0k0XS8FohA5xE3WKGE7HDY/R/ukNxqbTqTmyga5ihfSyT0e3bQDgpgZgfUEWLSfJRy24DLMApuVzwx6ShM01MUVqoCLiEGXn4mV9QvpxLbTCT33dss7+3G97un7+DD50=
41 |   - secure: AIsl7FMs3dsroJfQ2vRF1w/n/uW4BgSofXwPR2qF9OtsSL73wWwbMUNpNXwhDOVzjhOOI65uGqOa/LcoysCZhWR9GiI+xur8gd3pfl77YCaEmxUNSFOfYs3Zb32TtL3OAl3FeA6eEXDLR2+xOfQwBH5xYjuCooC8djT3Tee0kXs=
42 |   - secure: VzXxeZI3DJ9aUWahEXPwNE3Vmro158C2dNpt9sfznXOkX5Gy+ujKMwQ2ikv7dRtFhcYSPBwj7+liwygSRGsyirCiez0SILgmQA6BPNgLkD42ugM3CiXDlKHL15q3tsCJZBE+7JlWPqIfR/sdZC1cuZlaWJQXVzxwgnsXR98nI0Q=
43 |   - secure: pYk5Jm+PawXw2YtY0voKKzsAc/Q6iKnmF+br6LinWjR6UB7xOKyB6xJcyN0C5XNRDq7S2Y44P+yNSUe+E3LCRtTrBAbg4t4gjU7kBW3875OwiBoT3FgIFvVli3AxVW7G235+OQMZgD5RSjk48FK0NJTlUSbXJZbnlfUMM3bakHM=
44 | dd:
45 |   secure: f0Ky5jPniLh6FfbWC/oyB7QeQfM1OmaX75EvNFCnKhMJ0/HuDio4Nbgee024ztrTYeRpiAGAhTL3x3IwUtQ4XIsgFLW1iRKYdouEgZxh6kKoKygwAcmDK7hMEDmuUK7YqIRBKFDyaRreakHoX8dsPRfpEmOTLgVQ07+B3rdKJrI=
46 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/golang/protobuf/proto/message_set_test.go:
--------------------------------------------------------------------------------
 1 | // Go support for Protocol Buffers - Google's data interchange format
 2 | //
 3 | // Copyright 2014 The Go Authors.  All rights reserved.
 4 | // https://github.com/golang/protobuf
 5 | //
 6 | // Redistribution and use in source and binary forms, with or without
 7 | // modification, are permitted provided that the following conditions are
 8 | // met:
 9 | //
10 | //     * Redistributions of source code must retain the above copyright
11 | // notice, this list of conditions and the following disclaimer.
12 | //     * Redistributions in binary form must reproduce the above
13 | // copyright notice, this list of conditions and the following disclaimer
14 | // in the documentation and/or other materials provided with the
15 | // distribution.
16 | //     * Neither the name of Google Inc. nor the names of its
17 | // contributors may be used to endorse or promote products derived from
18 | // this software without specific prior written permission.
19 | //
20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 | 
32 | package proto
33 | 
34 | import (
35 | 	"bytes"
36 | 	"testing"
37 | )
38 | 
39 | func TestUnmarshalMessageSetWithDuplicate(t *testing.T) {
40 | 	// Check that a repeated message set entry will be concatenated.
41 | 	in := &MessageSet{
42 | 		Item: []*_MessageSet_Item{
43 | 			{TypeId: Int32(12345), Message: []byte("hoo")},
44 | 			{TypeId: Int32(12345), Message: []byte("hah")},
45 | 		},
46 | 	}
47 | 	b, err := Marshal(in)
48 | 	if err != nil {
49 | 		t.Fatalf("Marshal: %v", err)
50 | 	}
51 | 	t.Logf("Marshaled bytes: %q", b)
52 | 
53 | 	m := make(map[int32]Extension)
54 | 	if err := UnmarshalMessageSet(b, m); err != nil {
55 | 		t.Fatalf("UnmarshalMessageSet: %v", err)
56 | 	}
57 | 	ext, ok := m[12345]
58 | 	if !ok {
59 | 		t.Fatalf("Didn't retrieve extension 12345; map is %v", m)
60 | 	}
61 | 	// Skip wire type/field number and length varints.
62 | 	got := skipVarint(skipVarint(ext.enc))
63 | 	if want := []byte("hoohah"); !bytes.Equal(got, want) {
64 | 		t.Errorf("Combined extension is %q, want %q", got, want)
65 | 	}
66 | }
67 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/lib/pq/README.md:
--------------------------------------------------------------------------------
 1 | # pq - A pure Go postgres driver for Go's database/sql package
 2 | 
 3 | [![Build Status](https://travis-ci.org/lib/pq.png?branch=master)](https://travis-ci.org/lib/pq)
 4 | 
 5 | ## Install
 6 | 
 7 | 	go get github.com/lib/pq
 8 | 
 9 | ## Docs
10 | 
11 | For detailed documentation and basic usage examples, please see the package
12 | documentation at <http://godoc.org/github.com/lib/pq>.
13 | 
14 | ## Tests
15 | 
16 | `go test` is used for testing.  A running PostgreSQL server is
17 | required, with the ability to log in.  The default database to connect
18 | to test with is "pqgotest," but it can be overridden using environment
19 | variables.
20 | 
21 | Example:
22 | 
23 | 	PGHOST=/var/run/postgresql go test github.com/lib/pq
24 | 
25 | Optionally, a benchmark suite can be run as part of the tests:
26 | 
27 | 	PGHOST=/var/run/postgresql go test -bench .
28 | 
29 | ## Features
30 | 
31 | * SSL
32 | * Handles bad connections for `database/sql`
33 | * Scan `time.Time` correctly (i.e. `timestamp[tz]`, `time[tz]`, `date`)
34 | * Scan binary blobs correctly (i.e. `bytea`)
35 | * Package for `hstore` support
36 | * COPY FROM support
37 | * pq.ParseURL for converting urls to connection strings for sql.Open.
38 | * Many libpq compatible environment variables
39 | * Unix socket support
40 | * Notifications: `LISTEN`/`NOTIFY`
41 | 
42 | ## Future / Things you can help with
43 | 
44 | * Better COPY FROM / COPY TO (see discussion in #181)
45 | 
46 | ## Thank you (alphabetical)
47 | 
48 | Some of these contributors are from the original library `bmizerany/pq.go` whose
49 | code still exists in here.
50 | 
51 | * Andy Balholm (andybalholm)
52 | * Ben Berkert (benburkert)
53 | * Benjamin Heatwole (bheatwole)
54 | * Bill Mill (llimllib)
55 | * Bjørn Madsen (aeons)
56 | * Blake Gentry (bgentry)
57 | * Brad Fitzpatrick (bradfitz)
58 | * Charlie Melbye (cmelbye)
59 | * Chris Bandy (cbandy)
60 | * Chris Walsh (cwds)
61 | * Daniel Farina (fdr)
62 | * Eric Chlebek (echlebek)
63 | * Everyone at The Go Team
64 | * Evan Shaw (edsrzf)
65 | * Ewan Chou (coocood)
66 | * Federico Romero (federomero)
67 | * Fumin (fumin)
68 | * Gary Burd (garyburd)
69 | * Heroku (heroku)
70 | * James Pozdena (jpoz)
71 | * Jason McVetta (jmcvetta)
72 | * Jeremy Jay (pbnjay)
73 | * Joakim Sernbrant (serbaut)
74 | * John Gallagher (jgallagher)
75 | * Joël Stemmer (jstemmer)
76 | * Kamil Kisiel (kisielk)
77 | * Kelly Dunn (kellydunn)
78 | * Keith Rarick (kr)
79 | * Kir Shatrov (kirs)
80 | * Lann Martin (lann)
81 | * Maciek Sakrejda (deafbybeheading)
82 | * Marc Brinkmann (mbr)
83 | * Marko Tiikkaja (johto)
84 | * Matt Newberry (MattNewberry)
85 | * Matt Robenolt (mattrobenolt)
86 | * Martin Olsen (martinolsen)
87 | * Mike Lewis (mikelikespie)
88 | * Nicolas Patry (Narsil)
89 | * Oliver Tonnhofer (olt)
90 | * Patrick Hayes (phayes)
91 | * Paul Hammond (paulhammond)
92 | * Ryan Smith (ryandotsmith)
93 | * Samuel Stauffer (samuel)
94 | * Timothée Peignier (cyberdelia)
95 | * notedit (notedit)
96 | 


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/udpping1.go:
--------------------------------------------------------------------------------
  1 | //
  2 | //  UDP ping command
  3 | //  Model 1, does UDP work inline
  4 | //
  5 | 
  6 | //  this doesn't use ZeroMQ at all
  7 | 
  8 | package main
  9 | 
 10 | import (
 11 | 	"fmt"
 12 | 	"log"
 13 | 	"syscall"
 14 | 	"time"
 15 | )
 16 | 
 17 | const (
 18 | 	PING_PORT_NUMBER = 9999
 19 | 	PING_MSG_SIZE    = 1
 20 | 	PING_INTERVAL    = 1000 * time.Millisecond //  Once per second
 21 | )
 22 | 
 23 | func main() {
 24 | 
 25 | 	log.SetFlags(log.Lshortfile)
 26 | 
 27 | 	//  Create UDP socket
 28 | 	fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
 29 | 	if err != nil {
 30 | 		log.Fatalln(err)
 31 | 	}
 32 | 
 33 | 	//  Ask operating system to let us do broadcasts from socket
 34 | 	if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1); err != nil {
 35 | 		log.Fatalln(err)
 36 | 	}
 37 | 
 38 | 	//  Bind UDP socket to local port so we can receive pings
 39 | 	if err := syscall.Bind(fd, &syscall.SockaddrInet4{Port: PING_PORT_NUMBER, Addr: [4]byte{0, 0, 0, 0}}); err != nil {
 40 | 		log.Fatalln(err)
 41 | 	}
 42 | 
 43 | 	buffer := make([]byte, PING_MSG_SIZE)
 44 | 
 45 | 	//  We use syscall.Select to wait for activity on the UDP socket.
 46 | 	//  We send a beacon once a second, and we collect and report
 47 | 	//  beacons that come in from other nodes:
 48 | 
 49 | 	rfds := &syscall.FdSet{}
 50 | 	timeout := &syscall.Timeval{}
 51 | 
 52 | 	//  Send first ping right away
 53 | 	ping_at := time.Now()
 54 | 
 55 | 	bcast := &syscall.SockaddrInet4{Port: PING_PORT_NUMBER, Addr: [4]byte{255, 255, 255, 255}}
 56 | 	for {
 57 | 		dur := int64(ping_at.Sub(time.Now()) / time.Microsecond)
 58 | 		if dur < 0 {
 59 | 			dur = 0
 60 | 		}
 61 | 		timeout.Sec, timeout.Usec = dur/1000000, dur%1000000
 62 | 		FD_ZERO(rfds)
 63 | 		FD_SET(rfds, fd)
 64 | 		_, err := syscall.Select(fd+1, rfds, nil, nil, timeout)
 65 | 		if err != nil {
 66 | 			log.Fatalln(err)
 67 | 		}
 68 | 
 69 | 		//  Someone answered our ping
 70 | 		if FD_ISSET(rfds, fd) {
 71 | 			_, addr, err := syscall.Recvfrom(fd, buffer, 0)
 72 | 			if err != nil {
 73 | 				log.Fatalln(err)
 74 | 			}
 75 | 			a := addr.(*syscall.SockaddrInet4)
 76 | 			fmt.Printf("Found peer %v.%v.%v.%v:%v\n", a.Addr[0], a.Addr[1], a.Addr[2], a.Addr[3], a.Port)
 77 | 		}
 78 | 		if time.Now().After(ping_at) {
 79 | 			//  Broadcast our beacon
 80 | 			fmt.Println("Pinging peers...")
 81 | 			buffer[0] = '!'
 82 | 			if err := syscall.Sendto(fd, buffer, 0, bcast); err != nil {
 83 | 				log.Fatalln(err)
 84 | 			}
 85 | 			ping_at = time.Now().Add(PING_INTERVAL)
 86 | 		}
 87 | 	}
 88 | 
 89 | }
 90 | 
 91 | func FD_SET(p *syscall.FdSet, i int) {
 92 | 	p.Bits[i/64] |= 1 << uint(i) % 64
 93 | }
 94 | 
 95 | func FD_ISSET(p *syscall.FdSet, i int) bool {
 96 | 	return (p.Bits[i/64] & (1 << uint(i) % 64)) != 0
 97 | }
 98 | 
 99 | func FD_ZERO(p *syscall.FdSet) {
100 | 	for i := range p.Bits {
101 | 		p.Bits[i] = 0
102 | 	}
103 | }
104 | 


--------------------------------------------------------------------------------
/website/www/src/js/lib/bootstrap.d.ts:
--------------------------------------------------------------------------------
  1 | // Type definitions for Bootstrap 2.2
  2 | // Project: http://twitter.github.com/bootstrap/
  3 | // Definitions by: Boris Yankov <https://github.com/borisyankov/>
  4 | // Definitions: https://github.com/borisyankov/DefinitelyTyped
  5 | 
  6 | 
  7 | /// <reference path="jquery.d.ts"/>
  8 | 
  9 | interface ModalOptions {
 10 |     backdrop?: boolean;
 11 |     keyboard?: boolean;
 12 |     show?: boolean;
 13 |     remote?: string;
 14 | }
 15 | 
 16 | interface ModalOptionsBackdropString {
 17 |     backdrop?: string; // for "static"
 18 |     keyboard?: boolean;
 19 |     show?: boolean;
 20 |     remote?: string;
 21 | }
 22 | 
 23 | interface ScrollSpyOptions {
 24 |     offset?: number;
 25 | }
 26 | 
 27 | interface TooltipOptions {
 28 |     animation?: boolean;
 29 |     html?: boolean;
 30 |     placement?: any;
 31 |     selector?: string;
 32 |     title?: any;
 33 |     trigger?: string;
 34 |     delay?: any;
 35 |     container?: any;
 36 | }
 37 | 
 38 | interface PopoverOptions {
 39 |     animation?: boolean;
 40 |     html?: boolean;
 41 |     placement?: any;
 42 |     selector?: string;
 43 |     trigger?: string;
 44 |     title?: any;
 45 |     content?: any;
 46 |     delay?: any;
 47 |     container?: any;
 48 | }
 49 | 
 50 | interface CollapseOptions {
 51 |     parent?: any;    
 52 |     toggle?: boolean;
 53 | }
 54 | 
 55 | interface CarouselOptions {
 56 |     interval?: number;
 57 |     pause?: string;
 58 | }
 59 | 
 60 | interface TypeaheadOptions {
 61 |     source?: any;
 62 |     items?: number;
 63 |     minLength?: number;
 64 |     matcher?: (item: any) => boolean;
 65 |     sorter?: (items: any[]) => any[];
 66 |     updater?: (item: any) => any;
 67 |     highlighter?: (item: any) => string;
 68 | }
 69 | 
 70 | interface AffixOptions {
 71 |     offset?: any;
 72 | }
 73 | 
 74 | interface JQuery {
 75 |     modal(options?: ModalOptions): JQuery;
 76 |     modal(options?: ModalOptionsBackdropString): JQuery;
 77 |     modal(command: string): JQuery;
 78 | 
 79 |     dropdown(): JQuery;
 80 |     dropdown(command: string): JQuery;
 81 | 
 82 |     scrollspy(command: string): JQuery;
 83 |     scrollspy(options?: ScrollSpyOptions): JQuery;
 84 | 
 85 |     tab(): JQuery;
 86 |     tab(command: string): JQuery;
 87 | 
 88 |     tooltip(options?: TooltipOptions): JQuery;
 89 |     tooltip(command: string): JQuery;
 90 | 
 91 |     popover(options?: PopoverOptions): JQuery;
 92 |     popover(command: string): JQuery;
 93 | 
 94 |     alert(): JQuery;
 95 |     alert(command: string): JQuery;
 96 | 
 97 |     button(): JQuery;
 98 |     button(command: string): JQuery;
 99 | 
100 |     collapse(options?: CollapseOptions): JQuery;
101 |     collapse(command: string): JQuery;
102 | 
103 |     carousel(options?: CarouselOptions): JQuery;
104 |     carousel(command: string): JQuery;
105 | 
106 |     typeahead(options?: TypeaheadOptions): JQuery;
107 | 
108 |     affix(options?: AffixOptions): JQuery;
109 | }
110 | 
111 | declare module "bootstrap" {
112 | }


--------------------------------------------------------------------------------
/lib/Godeps/_workspace/src/github.com/pebbe/zmq4/examples/fileio3.go:
--------------------------------------------------------------------------------
  1 | //  File Transfer model #3
  2 | //
  3 | //  In which the client requests each chunk individually, using
  4 | //  command pipelining to give us a credit-based flow control.
  5 | 
  6 | package main
  7 | 
  8 | import (
  9 | 	zmq "github.com/pebbe/zmq4"
 10 | 
 11 | 	"fmt"
 12 | 	"os"
 13 | 	"strconv"
 14 | )
 15 | 
 16 | const (
 17 | 	CHUNK_SIZE = 250000
 18 | 	PIPELINE   = 10
 19 | )
 20 | 
 21 | func client_thread(pipe chan<- string) {
 22 | 	dealer, _ := zmq.NewSocket(zmq.DEALER)
 23 | 	dealer.Connect("tcp://127.0.0.1:6000")
 24 | 
 25 | 	//  Up to this many chunks in transit
 26 | 	credit := PIPELINE
 27 | 
 28 | 	total := 0  //  Total bytes received
 29 | 	chunks := 0 //  Total chunks received
 30 | 	offset := 0 //  Offset of next chunk request
 31 | 
 32 | 	for {
 33 | 		for credit > 0 {
 34 | 			//  Ask for next chunk
 35 | 			dealer.SendMessage("fetch", offset, CHUNK_SIZE)
 36 | 			offset += CHUNK_SIZE
 37 | 			credit--
 38 | 		}
 39 | 		chunk, err := dealer.RecvBytes(0)
 40 | 		if err != nil {
 41 | 			break //  Shutting down, quit
 42 | 		}
 43 | 		chunks++
 44 | 		credit++
 45 | 		size := len(chunk)
 46 | 		total += size
 47 | 		if size < CHUNK_SIZE {
 48 | 			break //  Last chunk received; exit
 49 | 		}
 50 | 	}
 51 | 	fmt.Printf("%v chunks received, %v bytes\n", chunks, total)
 52 | 	pipe <- "OK"
 53 | }
 54 | 
 55 | //  The rest of the code is exactly the same as in model 2, except
 56 | //  that we set the HWM on the server's ROUTER socket to PIPELINE
 57 | //  to act as a sanity check.
 58 | 
 59 | //  The server thread waits for a chunk request from a client,
 60 | //  reads that chunk and sends it back to the client:
 61 | 
 62 | func server_thread() {
 63 | 	file, err := os.Open("testdata")
 64 | 	if err != nil {
 65 | 		panic(err)
 66 | 	}
 67 | 
 68 | 	router, _ := zmq.NewSocket(zmq.ROUTER)
 69 | 	router.SetRcvhwm(PIPELINE * 2)
 70 | 	router.SetSndhwm(PIPELINE * 2)
 71 | 	router.Bind("tcp://*:6000")
 72 | 	for {
 73 | 		msg, err := router.RecvMessage(0)
 74 | 		if err != nil {
 75 | 			break //  Shutting down, quit
 76 | 		}
 77 | 		//  First frame in each message is the sender identity
 78 | 		identity := msg[0]
 79 | 
 80 | 		//  Second frame is "fetch" command
 81 | 		if msg[1] != "fetch" {
 82 | 			panic("command != \"fetch\"")
 83 | 		}
 84 | 
 85 | 		//  Third frame is chunk offset in file
 86 | 		offset, _ := strconv.ParseInt(msg[2], 10, 64)
 87 | 
 88 | 		//  Fourth frame is maximum chunk size
 89 | 		chunksz, _ := strconv.Atoi(msg[3])
 90 | 
 91 | 		//  Read chunk of data from file
 92 | 		chunk := make([]byte, chunksz)
 93 | 		n, _ := file.ReadAt(chunk, offset)
 94 | 
 95 | 		//  Send resulting chunk to client
 96 | 		router.SendMessage(identity, chunk[:n])
 97 | 	}
 98 | 	file.Close()
 99 | }
100 | 
101 | //  The main task is just the same as in the first model.
102 | 
103 | func main() {
104 | 	pipe := make(chan string)
105 | 
106 | 	//  Start child threads
107 | 	go server_thread()
108 | 	go client_thread(pipe)
109 | 	//  Loop until client tells us it's done
110 | 	<-pipe
111 | }
112 | 


--------------------------------------------------------------------------------