コード例 #1
0
// NewPostgresReadRepository creates a new PostgresReadRepository.
func NewPostgresReadRepository(conn, table string) (*PostgresReadRepository, error) {
	lgr := lager.Child()
	lgr.Set("table", table)

	db, err := initDB(conn)
	if err != nil {
		return nil, err
	}

	create := fmt.Sprintf(`
CREATE EXTENSION IF NOT EXISTS "uuid-ossp" WITH SCHEMA public;

CREATE TABLE IF NOT EXISTS %s (
  data jsonb
);
`, table)

	_, err = db.Exec(create)
	if err != nil {
		return nil, ErrCouldNotCreateTables
	}

	stmts := map[string]string{
		"save":    fmt.Sprintf("INSERT INTO %s (data) VALUES ($1)", table),
		"find":    fmt.Sprintf("SELECT * FROM %s WHERE data->>'id'=$1", table),
		"findall": fmt.Sprintf("SELECT * FROM %s", table),
		"remove":  fmt.Sprintf("DELETE FROM %s WHERE data->>'id'=$1", table),
		"clear":   fmt.Sprintf("DELETE FROM %s", table),
		"update":  fmt.Sprintf("UPDATE %s set data=$1 WHERE data->>'id'=$2", table),
	}

	return &PostgresReadRepository{
		db:    db,
		table: table,
		stmts: stmts,
		lgr:   lgr,
	}, nil
}
コード例 #2
0
// NewPostgresEventStore creates a new PostgresEventStore.
func NewPostgresEventStore(eventBus EventBus, conn string) (*PostgresEventStore, error) {
	lgr := lager.Child()

	db, err := initDB(conn)
	if err != nil {
		lgr.WithError(err).Errorf("Unable to initialize database")
		return nil, err
	}

	if _, err = db.Exec(`
CREATE EXTENSION IF NOT EXISTS "uuid-ossp" WITH SCHEMA public;

CREATE TABLE IF NOT EXISTS aggregrates (
  id uuid NOT NULL,
  version int NOT NULL
);

CREATE TABLE IF NOT EXISTS events(
  aggregrateid uuid NOT NULL,
  type text,
  version int,
  timestamp timestamp without time zone default (now() at time zone 'utc'),
  data jsonb
)
    `); err != nil {
		db.Close()
		lgr.WithError(err).Errorf("Unable to initialize tables")
		return nil, ErrCouldNotCreateTables
	}

	return &PostgresEventStore{
		eventBus:  eventBus,
		db:        db,
		factories: make(map[string]func() Event),
		lgr:       lgr,
	}, nil
}
コード例 #3
0
// NewRabbitMQCommandBus creates a new RabbitMQ command bus. amqpURI is the RabbitMQ
// URI for rabbitmq. app is provides a namespace for this application, allowing
// for multiple command buses to run on one RabbitMQ and not conflict with eachother.
// tag is used as the RabbitMQ consumer tag for this bus.
func NewRabbitMQCommandBus(amqpURI, app, tag string) (*RabbitMQCommandBus, error) {
	lgr := lager.Child()

	connection, err := amqp.Dial(amqpURI)
	if err != nil {
		lgr.WithError(err).Errorf("Error dialing URI: %s", amqpURI)
		return nil, fmt.Errorf("Dial err: %s", err)
	}

	channel, err := connection.Channel()
	if err != nil {
		connection.Close()
		lgr.WithError(err).Errorf("Error opening channel")
		return nil, fmt.Errorf("Channel: %s", err)
	}

	exchange := appExchange(app, commandExchange)
	queueName := appTagQueueName(app, tag, commandQueueName)

	if err := channel.ExchangeDeclare(
		exchange,            // name
		commandExchangeType, // type
		true,                // durable
		false,               // auto-deleted
		false,               // internal
		false,               // noWait
		nil,                 // arguments
	); err != nil {
		channel.Close()
		connection.Close()
		lgr.WithError(err).Errorf("Error declaring exchange :%s", exchange)
		return nil, fmt.Errorf("Exchange Declare: %s", err)
	}

	queue, err := channel.QueueDeclare(
		queueName, // name of the queue
		true,      // durable
		false,     // delete when usused
		false,     // exclusive
		false,     // noWait
		nil,       // arguments
	)
	if err != nil {
		channel.Close()
		connection.Close()
		lgr.WithError(err).Errorf("Error declaring queue %s", queueName)
		return nil, fmt.Errorf("Queue Declare: %s", err)
	}

	if err = channel.QueueBind(
		queue.Name, // name of the queue
		commandKey, // bindingKey
		exchange,   // sourceExchange
		false,      // noWait
		nil,        // arguments
	); err != nil {
		channel.Close()
		connection.Close()
		lgr.WithError(err).Errorf("Error binding queue %s", queueName)
		return nil, fmt.Errorf("Queue Bind: %s", err)
	}

	deliveries, err := channel.Consume(
		queue.Name, // name
		tag,        // consumerTag,
		false,      // noAck
		false,      // exclusive
		false,      // noLocal
		false,      // noWait
		nil,        // arguments
	)
	if err != nil {
		channel.Close()
		connection.Close()
		lgr.WithError(err).Errorf("Error consuming queue %s", queueName)
		return nil, fmt.Errorf("Queue Consume: %s", err)
	}

	bus := &RabbitMQCommandBus{
		conn:      connection,
		channel:   channel,
		exchange:  exchange,
		queue:     queueName,
		tag:       tag,
		handlers:  make(map[string]CommandHandler),
		factories: make(map[string]func() Command),
		done:      make(chan error),
		lgr:       lgr,
	}

	go bus.handleCommands(deliveries, bus.done)
	return bus, nil
}