 San Antonio is a contemporary Texas art foundation with a residency and exhibition program, featuring cutting edge international art. Admission is free.
The Center for Contemporary Arts is an alternative space with four galleries that offers visitors over 19 exhibits annually which embrace Texas contemporary art and artists.
The best little old art center in West Texas. A unique compound of galleries, studios, restaurant and bed and breakfast with events and workshops.
The Creative Arts Center of Dallas provides a nurturing environment for people to discover, develop and express their artistic visions.
Fredericksburg Artists' School is dedicated to bring professional artists to the beautiful setting of Fredericksburg in order to instruct and encourage art students.
We provide a cultural atmosphere, including art classes and theatre for professionals and amateurs, plus special children's programs.
Houston Center for Contemporary Craft's mission is to advance education about the process, product, and history of craft.
Texas Hill Country Kerrville's Kerr County Arts Center is the place for all art.
The Southwest School of Art & Craft connects people with their creative selves, explores how objects convey meaning, and links the community to its artistic, cultural and historic traditions.<filename>scripts/commands/cfn/index.md
# `awsinfo cfn [filters]*`

List all CloudFormation stacks

## Filter matches against

* StackName
<gh_stars>1-10
package btcdnotify

import (
	"container/heap"
	"sync"
	"sync/atomic"
	"time"

	"github.com/lightningnetwork/lnd/chainntnfs"
	"github.com/roasbeef/btcd/btcjson"
	"github.com/roasbeef/btcd/wire"
	"github.com/roasbeef/btcrpcclient"
	"github.com/roasbeef/btcutil"
)

const (

	// notifierType uniquely identifies this concrete implementation of the
	// ChainNotifier interface.
	notifierType = "btcd"
)

// BtcdNotifier implements the ChainNotifier interface using btcd's websockets
// notifications. Multiple concurrent clients are supported. All notifications
// are achieved via non-blocking sends on client channels.
type BtcdNotifier struct {
	started int32 // To be used atomically.
	stopped int32 // To be used atomically.

	chainConn *btcrpcclient.Client

	notificationRegistry chan interface{}

	// TODO(roasbeef): make map point to slices? Would allow for multiple
	// clients to listen for same spend. Would we ever need this?
	spendNotifications map[wire.OutPoint]*spendNotification

	confNotifications map[wire.ShaHash][]*confirmationsNotification
	confHeap          *confirmationHeap

	blockEpochClients []chan *chainntnfs.BlockEpoch

	connectedBlockHashes    chan *blockNtfn
	disconnectedBlockHashes chan *blockNtfn
	relevantTxs             chan *btcutil.Tx

	wg   sync.WaitGroup
	quit chan struct{}
}

// Ensure BtcdNotifier implements the ChainNotifier interface at compile time.
var _ chainntnfs.ChainNotifier = (*BtcdNotifier)(nil)

// New returns a new BtcdNotifier instance. This function assumes the btcd node
// detailed in the passed configuration is already running, and
// willing to accept new websockets clients.
func New(config *btcrpcclient.ConnConfig) (*BtcdNotifier, error) {
	notifier := &BtcdNotifier{
		notificationRegistry: make(chan interface{}),

		spendNotifications: make(map[wire.OutPoint]*spendNotification),
		confNotifications:  make(map[wire.ShaHash][]*confirmationsNotification),
		confHeap:           newConfirmationHeap(),

		connectedBlockHashes:    make(chan *blockNtfn, 20),
		disconnectedBlockHashes: make(chan *blockNtfn, 20),
		relevantTxs:             make(chan *btcutil.Tx, 100),

		quit: make(chan struct{}),
	}

	ntfnCallbacks := &btcrpcclient.NotificationHandlers{
		OnBlockConnected:    notifier.onBlockConnected,
		OnBlockDisconnected: notifier.onBlockDisconnected,
		OnRedeemingTx:       notifier.onRedeemingTx,
	}

	// Disable connecting to btcd within the btcrpcclient.New method. We
	// defer establishing the connection to our.Start() method.
	config.DisableConnectOnNew = true
	config.DisableAutoReconnect = false
	chainConn, err := btcrpcclient.New(config, ntfnCallbacks)
	if err!= nil {
		return nil, err
	}
	notifier.chainConn = chainConn

	return notifier, nil
}

// Start connects to the running btcd node over websockets, registers for block
// notifications, and finally launches all related helper goroutines.
func (b *BtcdNotifier) Start() error {
	// Already started?
	if atomic.AddInt32(&b.started, 1)!= 1 {
		return nil
	}

	// Connect to btcd, and register for notifications on connected, and
	// disconnected blocks.
	if err := b.chainConn.Connect(20); err!= nil {
		return err
	}
	if err := b.chainConn.NotifyBlocks(); err!= nil {
		return err
	}

	b.wg.Add(1)
	go b.notificationDispatcher()

	return nil
}

// Stop shutsdown the BtcdNotifier.
func (b *BtcdNotifier) Stop() error {
	// Already shutting down?
	if atomic.AddInt32(&b.stopped, 1)!= 1 {
		return nil
	}

	// Shutdown the rpc client, this gracefully disconnects from btcd, and
	// cleans up all related resources.
	b.chainConn.Shutdown()

	close(b.quit)
	b.wg.Wait()

	// Notify all pending clients of our shutdown by closing the related
	// notification channels.
	for _, spendClient := range b.spendNotifications {
		close(spendClient.spendChan)
	}
	for _, confClients := range b.confNotifications {
		for _, confClient := range confClients {
			close(confClient.finConf)
			close(confClient.negativeConf)
		}
	}

	return nil
}

// blockNtfn packages a notification of a connected/disconnected block along
// with its height at the time.
type blockNtfn struct {
	sha    *wire.ShaHash
	height int32
}

// onBlockConnected implements on OnBlockConnected callback for btcrpcclient.
func (b *BtcdNotifier) onBlockConnected(hash *wire.ShaHash, height int32, t time.Time) {
	select {
	case b.connectedBlockHashes <- &blockNtfn{hash, height}:
	case <-b.quit:
	}
}

// onBlockDisconnected implements on OnBlockDisconnected callback for btcrpcclient.
func (b *BtcdNotifier) onBlockDisconnected(hash *wire.ShaHash, height int32, t time.Time) {
}

// onRedeemingTx implements on OnRedeemingTx callback for btcrpcclient.
func (b *BtcdNotifier) onRedeemingTx(transaction *btcutil.Tx, details *btcjson.BlockDetails) {
	select {
	case b.relevantTxs <- transaction:
	case <-b.quit:
	}
}

// notificationDispatcher is the primary goroutine which handles client
// notification registrations, as well as notification dispatches.
func (b *BtcdNotifier) notificationDispatcher() {
out:
	for {
		select {
		case registerMsg := <-b.notificationRegistry:
			switch msg := registerMsg.(type) {
			case *spendNotification:
				chainntnfs.Log.Infof("New spend subscription: "+
					"utxo=%v", msg.targetOutpoint)
				b.spendNotifications[*msg.targetOutpoint] = msg
			case *confirmationsNotification:
				chainntnfs.Log.Infof("New confirmations "+
					"subscription: txid=%v, numconfs=%v",
					*msg.txid, msg.numConfirmations)
				txid := *msg.txid
				b.confNotifications[txid] = append(b.confNotifications[txid], msg)
			case *block