x/box-o-sand
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Archiving a bunch of old stuff

Browse Source
This commit is contained in:
Dan Buch
2015-06-22 13:15:42 -05:00
parent a6ec1d560e
commit bd1abd8734
395 changed files with 1 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
oldstuff/sylvilagus/go/.gitignore vendored Normal file
View File

@@ -0,0 +1,2 @@
/bin
/.env

18
oldstuff/sylvilagus/go/Makefile Normal file
View File

@@ -0,0 +1,18 @@
REPO_BASE := github.com/meatballhat/box-o-sand/sylvilagus/go
PACKAGES := \
$(REPO_BASE)/sylvilagus-conntest \
$(REPO_BASE)/sylvilagus-ch02-hello-world-consumer \
$(REPO_BASE)/sylvilagus-ch02-hello-world-producer \
$(REPO_BASE)/sylvilagus-ch04-rpc-server \
$(REPO_BASE)/sylvilagus-ch04-rpc-client
test: build
go test -x -v $(PACKAGES)
build: deps
go install -x $(PACKAGES)
deps:
go get -x $(PACKAGES)
.PHONY: test build deps

45
oldstuff/sylvilagus/go/sylvilagus-ch02-hello-world-consumer/main.go Normal file
View File

@@ -0,0 +1,45 @@
package main
import (
"log"
)
import (
"github.com/meatballhat/box-o-sand/sylvilagus/go/sylvilagus"
"github.com/streadway/amqp"
)
func main() {
connection, err := amqp.Dial(sylvilagus.AMQP_URI)
if err != nil {
log.Fatal("Failed to connect!: ", err)
}
defer connection.Close()
channel, err := sylvilagus.CreateHelloTopology(connection)
if err != nil {
log.Fatal("Failed to build topology!: ", err)
}
hellos, err := channel.Consume("hello-queue", "hello-consumer", false, false, false, false, nil)
if err != nil {
log.Fatal("Failed to start consuming!:", err)
}
quit := make(chan bool)
go func(quit chan bool) {
log.Println("Consuming...")
for hello := range hellos {
log.Printf("hello -> %v\n", string(hello.Body))
hello.Ack(false)
if string(hello.Body) == "quit" {
quit <- true
return
}
}
}(quit)
<-quit
}

46
oldstuff/sylvilagus/go/sylvilagus-ch02-hello-world-producer/main.go Normal file
View File

@@ -0,0 +1,46 @@
package main
import (
"log"
"os"
"time"
)
import (
"github.com/meatballhat/box-o-sand/sylvilagus/go/sylvilagus"
"github.com/streadway/amqp"
)
func main() {
if len(os.Args) < 2 {
log.Fatal("You must provide a message as first arg!")
}
msgBody := string(os.Args[1])
connection, err := amqp.Dial(sylvilagus.AMQP_URI)
if err != nil {
log.Fatal("Failed to connect!: ", err)
}
defer connection.Close()
channel, err := sylvilagus.CreateHelloTopology(connection)
if err != nil {
log.Fatal("Failed to build topology!: ", err)
}
msg := amqp.Publishing{
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
ContentType: "text/plain",
Body: []byte(msgBody),
}
err = channel.Publish("hello-exchange", "hola", false, false, msg)
if err != nil {
log.Fatal("Failed to publish message!: ", err)
} else {
log.Printf("Published '%v'\n", msgBody)
}
}

63
oldstuff/sylvilagus/go/sylvilagus-ch04-rpc-client/main.go Normal file
View File

@@ -0,0 +1,63 @@
package main
import (
"encoding/json"
"log"
"time"
)
import (
"github.com/meatballhat/box-o-sand/sylvilagus/go/sylvilagus"
"github.com/streadway/amqp"
)
func main() {
connection, err := amqp.Dial(sylvilagus.AMQP_URI)
if err != nil {
log.Fatal("Failed to connect!:", err)
}
defer connection.Close()
channel, err := sylvilagus.CreateRPCTopology(connection)
if err != nil {
log.Fatal("Failed to build topology!:", err)
}
qResult, err := channel.QueueDeclare("", false, false, true, false, nil)
if err != nil {
log.Fatal("Failed to build topology!:", err)
}
msgBody := &sylvilagus.Ping{
ClientName: "RPC Client 1.0",
Time: time.Now(),
}
msgBytes, err := json.Marshal(msgBody)
if err != nil {
log.Fatal("Failed to json.Marshal the ping!:", err)
}
msg := amqp.Publishing{
ContentType: "application/json",
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
Body: msgBytes,
ReplyTo: qResult.Name,
}
channel.Publish("rpc", "ping", false, false, msg)
log.Println("Sent 'ping' RPC call:", string(msg.Body))
log.Println("Waiting for reply...")
pongs, err := channel.Consume(qResult.Name, qResult.Name, false, false, false, false, nil)
for pong := range pongs {
log.Println("RPC Reply ---", string(pong.Body))
if err = channel.Close(); err != nil {
log.Fatal("Failed to close channel!:", err)
} else {
return
}
}
}

63
oldstuff/sylvilagus/go/sylvilagus-ch04-rpc-server/main.go Normal file
View File

@@ -0,0 +1,63 @@
package main
import (
"encoding/json"
"fmt"
"log"
"time"
)
import (
"github.com/meatballhat/box-o-sand/sylvilagus/go/sylvilagus"
"github.com/streadway/amqp"
)
func main() {
connection, err := amqp.Dial(sylvilagus.AMQP_URI)
if err != nil {
log.Fatal("Failed to connect!:", err)
}
defer connection.Close()
channel, err := sylvilagus.CreateRPCTopology(connection)
if err != nil {
log.Fatal("Failed to build topology!:", err)
}
pings, err := channel.Consume("ping", "ping", false, false, false, false, nil)
if err != nil {
log.Fatal("Failed to start consuming!:", err)
}
quit := make(chan bool)
go func(quit chan bool) {
log.Println("Waiting for RPC calls...")
for ping := range pings {
if err = ping.Ack(false); err == nil {
log.Println("Received API call... replying...")
pingInst := &sylvilagus.Ping{}
err = json.Unmarshal(ping.Body, pingInst)
if err == nil {
msg := amqp.Publishing{
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
ContentType: "text/plain",
Body: []byte(fmt.Sprintf("Pong! %s", pingInst.Time)),
}
channel.Publish("", ping.ReplyTo, false, false, msg)
} else {
log.Println("Failed to json.Unmarshal the ping!:", err)
}
} else {
log.Println("Failed to ACK the ping!:", err)
}
}
}(quit)
<-quit
}

41
oldstuff/sylvilagus/go/sylvilagus-conntest/main.go Normal file
View File

@@ -0,0 +1,41 @@
package main
import (
"flag"
"fmt"
"log"
)
import (
"github.com/streadway/amqp"
)
var (
connUri = flag.String("connuri", "amqp://guest:guest@localhost:5672/sylvilagus", "Connection URI for AMQP thingy")
)
func main() {
flag.Parse()
fmt.Printf("Connecting to %v...\n", *connUri)
conn, err := amqp.Dial(*connUri)
defer conn.Close()
if err != nil {
log.Fatal("err:", err)
}
if conn != nil {
log.Println("conn:", conn)
}
channel, err := conn.Channel()
if err != nil {
log.Fatal("err:", err)
}
if channel != nil {
log.Println("channel:", channel)
}
}

1
oldstuff/sylvilagus/go/sylvilagus.go Normal file
View File

@@ -0,0 +1 @@
package sylvilagus

37
oldstuff/sylvilagus/go/sylvilagus/hello.go Normal file
View File

@@ -0,0 +1,37 @@
package sylvilagus
import (
"log"
)
import (
"github.com/streadway/amqp"
)
func CreateHelloTopology(connection *amqp.Connection) (*amqp.Channel, error) {
channel, err := connection.Channel()
if err != nil {
log.Println("Failed to get channel!: ", err)
return nil, err
}
err = channel.ExchangeDeclare("hello-exchange", "direct", true, false, false, false, nil)
if err != nil {
log.Println("Failed to declare exchange!: ", err)
return nil, err
}
_, err = channel.QueueDeclare("hello-queue", false, false, false, false, nil)
if err != nil {
log.Println("Failed to declare queue!: ", err)
return nil, err
}
err = channel.QueueBind("hello-queue", "hola", "hello-exchange", false, nil)
if err != nil {
log.Println("Failed to bind to queue!: ", err)
return nil, err
}
return channel, nil
}

39
oldstuff/sylvilagus/go/sylvilagus/rpc.go Normal file
View File

@@ -0,0 +1,39 @@
package sylvilagus
import (
"log"
"time"
)
import (
"github.com/streadway/amqp"
)
type Ping struct {
ClientName string `json:"client_name"`
Time time.Time `json:"time"`
}
func CreateRPCTopology(connection *amqp.Connection) (channel *amqp.Channel, err error) {
if channel, err = connection.Channel(); err != nil {
log.Println("Failed to get channel!: ", err)
return nil, err
}
if err = channel.ExchangeDeclare("rpc", "direct", true, false, false, false, nil); err != nil {
log.Println("Failed to declare exchange!: ", err)
return nil, err
}
if _, err = channel.QueueDeclare("ping", false, false, false, false, nil); err != nil {
log.Println("Failed to declare queue!: ", err)
return nil, err
}
if err = channel.QueueBind("ping", "ping", "rpc", false, nil); err != nil {
log.Println("Failed to bind to queue!: ", err)
return nil, err
}
return channel, nil
}

14
oldstuff/sylvilagus/go/sylvilagus/uri.go Normal file
View File

@@ -0,0 +1,14 @@
package sylvilagus
import (
"log"
"os"
)
var AMQP_URI = os.Getenv("SYLVILAGUS_AMQP_URI")
func init() {
if len(AMQP_URI) < 1 {
log.Fatal("SYLVILAGUS_AMQP_URI is not defined!")
}
}