github.com/Cloud-Foundations/Dominator@v0.3.4/lib/slavedriver/api.go (about)

     1  package slavedriver
     2  
     3  import (
     4  	"container/list"
     5  	"io"
     6  	"net"
     7  	"time"
     8  
     9  	"github.com/Cloud-Foundations/Dominator/lib/log"
    10  	"github.com/Cloud-Foundations/Dominator/lib/srpc"
    11  )
    12  
    13  type Slave struct {
    14  	acknowledgeChannel chan<- chan<- error
    15  	clientAddress      string
    16  	driver             *SlaveDriver
    17  	info               SlaveInfo
    18  	client             *srpc.Client
    19  	timeToPing         time.Time
    20  	pinging            bool
    21  }
    22  
    23  func (slave *Slave) Destroy() {
    24  	slave.driver.destroySlaveChannel <- slave
    25  }
    26  
    27  func (slave *Slave) GetClient() *srpc.Client {
    28  	return slave.getClient()
    29  }
    30  
    31  func (slave *Slave) GetClientAddress() string {
    32  	return slave.clientAddress
    33  }
    34  
    35  func (slave *Slave) Release() {
    36  	slave.driver.releaseSlaveChannel <- slave
    37  }
    38  
    39  func (slave *Slave) String() string {
    40  	return slave.info.Identifier
    41  }
    42  
    43  type SlaveDriver struct {
    44  	options             SlaveDriverOptions
    45  	destroySlaveChannel chan<- *Slave
    46  	getSlaveChannel     chan<- requestSlaveMessage
    47  	getSlavesChannel    chan<- chan<- slaveRoll
    48  	logger              log.DebugLogger
    49  	releaseSlaveChannel chan<- *Slave
    50  	replaceIdleChannel  chan<- bool
    51  }
    52  
    53  func NewSlaveDriver(options SlaveDriverOptions, slaveTrader SlaveTrader,
    54  	logger log.DebugLogger) (*SlaveDriver, error) {
    55  	return newSlaveDriver(options, slaveTrader,
    56  		dialWithRetry, &jsonDatabase{options.DatabaseFilename}, logger)
    57  }
    58  
    59  func (driver *SlaveDriver) GetSlave() (*Slave, error) {
    60  	return driver.getSlave(-1)
    61  }
    62  
    63  func (driver *SlaveDriver) GetSlaveWithTimeout(timeout time.Duration) (
    64  	*Slave, error) {
    65  	return driver.getSlave(timeout)
    66  }
    67  
    68  func (driver *SlaveDriver) ReplaceIdle(immediateGetNew bool) {
    69  	driver.replaceIdleChannel <- immediateGetNew
    70  }
    71  
    72  func (driver *SlaveDriver) WriteHtml(writer io.Writer) {
    73  	driver.writeHtml(writer)
    74  }
    75  
    76  type SlaveDriverOptions struct {
    77  	DatabaseFilename  string
    78  	MaximumIdleSlaves uint
    79  	MinimumIdleSlaves uint
    80  	PortNumber        uint
    81  	Purpose           string
    82  }
    83  
    84  type SlaveInfo struct {
    85  	Identifier string
    86  	IpAddress  net.IP
    87  }
    88  
    89  func (si SlaveInfo) String() string {
    90  	return si.Identifier
    91  }
    92  
    93  type SlaveTrader interface {
    94  	Close() error
    95  	CreateSlave() (SlaveInfo, error)
    96  	DestroySlave(identifier string) error
    97  }
    98  
    99  type SlaveTraderAcknowledger interface {
   100  	CreateSlaveWithAcknowledger(<-chan chan<- error) (SlaveInfo, error)
   101  }
   102  
   103  type clientDialerFunc func(string, string, time.Duration) (*srpc.Client, error)
   104  
   105  type databaseLoadSaver interface {
   106  	load() (*slaveRoll, error)
   107  	save(slaveRoll) error
   108  }
   109  
   110  type pingResponseMessage struct {
   111  	error error
   112  	slave *Slave
   113  }
   114  
   115  type requestSlaveMessage struct {
   116  	slaveChannel chan<- *Slave
   117  	timeout      time.Time
   118  }
   119  
   120  type slaveDriver struct {
   121  	options               SlaveDriverOptions
   122  	busySlaves            map[*Slave]struct{}
   123  	clientDialer          clientDialerFunc
   124  	createdSlaveChannel   <-chan *Slave
   125  	destroySlaveChannel   <-chan *Slave
   126  	destroyedSlaveChannel <-chan *Slave
   127  	databaseDriver        databaseLoadSaver
   128  	getSlaveChannel       <-chan requestSlaveMessage
   129  	getSlavesChannel      <-chan chan<- slaveRoll
   130  	getterList            *list.List
   131  	idleSlaves            map[*Slave]struct{}
   132  	logger                log.DebugLogger
   133  	pingResponseChannel   chan pingResponseMessage
   134  	publicDriver          *SlaveDriver
   135  	releaseSlaveChannel   <-chan *Slave
   136  	replaceIdleChannel    <-chan bool
   137  	slaveTrader           SlaveTrader
   138  	writeState            bool
   139  	zombies               map[*Slave]struct{}
   140  }
   141  
   142  type slaveRoll struct {
   143  	BusySlaves []SlaveInfo `json:",omitempty"`
   144  	IdleSlaves []SlaveInfo `json:",omitempty"`
   145  	Zombies    []SlaveInfo `json:",omitempty"`
   146  }