// This updates the shard manager to use new shard states.
func (m *BaseShardManager) UpdateShardStates(shardStates []ShardState) {
newAddrs := set.NewSet()
for _, state := range shardStates {
newAddrs.Add(state.Address)
}
m.rwMutex.Lock()
defer m.rwMutex.Unlock()
oldAddrs := set.NewSet()
for _, state := range m.shardStates {
oldAddrs.Add(state.Address)
}
for address := range set.Subtract(newAddrs, oldAddrs).Iter() {
if err := m.pool.Register("tcp", address.(string)); err != nil {
m.logError(err)
}
}
for address := range set.Subtract(oldAddrs, newAddrs).Iter() {
if err := m.pool.Unregister("tcp", address.(string)); err != nil {
m.logError(err)
}
}
m.shardStates = shardStates
}
func New(name string) (module *Module) {
module = &Module{
name: name,
before: set.NewSet(),
after: set.NewSet(),
}
modules.PushBack(module)
return
}
// Samples 'k' unique ints from the range [0, n)
func SampleInts(n int, k int) (res []int, err error) {
if k < 0 {
err = errors.Newf("invalid sample size k")
return
}
if n < k {
err = errors.Newf("sample size k larger than n")
return
}
picked := set.NewSet()
for picked.Len() < k {
i := Intn(n)
picked.Add(i)
}
res = make([]int, k)
e := 0
for i := range picked.Iter() {
res[e] = i.(int)
e++
}
return
}
func (c *Oauth2Client) Refresh(db *database.Database) (err error) {
refreshed, err := c.Check()
if err != nil {
return
}
if !refreshed {
return
}
coll := db.Accounts()
c.Account.Oauth2AccTokn = c.AccessToken
c.Account.Oauth2RefTokn = c.RefreshToken
c.Account.Oauth2Exp = c.Expiry
if c.Account.Id == "" {
return
}
fields := set.NewSet("oauth2_acc_tokn", "oauth2_ref_tokn", "oauth2_exp")
err = coll.CommitFields(c.Account.Id, c.Account, fields)
if err != nil {
err = database.ParseError(err)
return
}
return
}
func getTargets(path string) (targets []string, err error) {
pac, err := parse.File("", "", path)
if err != nil {
return
}
err = pac.Compile()
if err != nil {
return
}
tarSet := set.NewSet()
for _, target := range pac.Targets {
tarSet.Add(target)
}
for _, release := range constants.Releases {
distro := strings.Split(release, "-")[0]
if tarSet.Contains("!"+release) || tarSet.Contains("!"+distro) {
continue
}
if tarSet.Contains(release) || tarSet.Contains(distro) {
targets = append(targets, release)
}
}
return
}
func StringSet(items []string) (s set.Set) {
s = set.NewSet()
for _, item := range items {
s.Add(item)
}
return
}
func (s *RoundRobinResourcePoolSuite) TestRegisterAndGet(c *C) {
s.SetupPool(c, 10)
err := s.pool.Register("foo")
c.Assert(err, IsNil)
err = s.pool.Register("bar")
c.Assert(err, IsNil)
err = s.pool.Register("abc")
c.Assert(err, IsNil)
err = s.pool.Register("zzz")
c.Assert(err, IsNil)
locations := make([]string, 0)
locSet := set.NewSet()
c1, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c1.ResourceLocation())
locSet.Add(c1.ResourceLocation())
c2, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c2.ResourceLocation())
locSet.Add(c2.ResourceLocation())
c3, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c3.ResourceLocation())
locSet.Add(c3.ResourceLocation())
c4, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c4.ResourceLocation())
locSet.Add(c4.ResourceLocation())
expected := set.NewSet("foo", "bar", "abc", "zzz")
c.Assert(locSet.IsEqual(expected), IsTrue)
for i := 0; i < 20; i++ {
h, err := s.pool.Get("")
c.Assert(err, IsNil)
c.Assert(h.ResourceLocation(), Equals, locations[i%4])
}
}
func (r *Redhat) getFiles() (files []string, err error) {
backup := set.NewSet()
paths := set.NewSet()
for _, path := range r.Pack.Backup {
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
backup.Add(path)
}
rpmPath, err := r.getRpmPath()
if err != nil {
return
}
output, err := utils.ExecOutput(r.Pack.PackageDir, "rpm", "-qlp", rpmPath)
if err != nil {
return
}
for _, path := range strings.Split(output, "\n") {
if len(path) < 1 {
continue
}
paths.Remove(filepath.Dir(path))
paths.Add(path)
}
for pathInf := range paths.Iter() {
path := pathInf.(string)
if backup.Contains(path) {
path = `%config "` + path + `"`
} else {
path = `"` + path + `"`
}
files = append(files, path)
}
return
}
func (s *ManagerSuite) TestRegister(c *C) {
shardStates := make([]ShardState, 4)
shardStates[0].Address = "foo"
shardStates[1].Address = "bar"
shardStates[2].Address = "baz"
shardStates[3].Address = "foo"
s.manager.UpdateShardStates(shardStates)
expectedRegistered := set.NewSet("foo", "bar", "baz")
c.Assert(expectedRegistered.IsEqual(s.pool.registered), IsTrue)
}
func (s *RoundRobinResourcePoolSuite) TestInitWithPools(c *C) {
foo := s.CreateResourceLocationPool("foo")
bar := s.CreateResourceLocationPool("bar")
abc := s.CreateResourceLocationPool("abc")
zzz := s.CreateResourceLocationPool("zzz")
s.SetupPool(c, 10, foo, bar, abc, zzz)
locations := make([]string, 0)
locSet := set.NewSet()
c1, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c1.ResourceLocation())
locSet.Add(c1.ResourceLocation())
c2, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c2.ResourceLocation())
locSet.Add(c2.ResourceLocation())
c3, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c3.ResourceLocation())
locSet.Add(c3.ResourceLocation())
c4, err := s.pool.Get("")
c.Assert(err, IsNil)
locations = append(locations, c4.ResourceLocation())
locSet.Add(c4.ResourceLocation())
expected := set.NewSet("foo", "bar", "abc", "zzz")
c.Assert(locSet.IsEqual(expected), IsTrue)
for i := 0; i < 20; i++ {
h, err := s.pool.Get("")
c.Assert(err, IsNil)
c.Assert(h.ResourceLocation(), Equals, locations[i%4])
}
}
// Event system for client using web socket.
package event
import (
"github.com/dropbox/godropbox/container/set"
"github.com/pritunl/pritunl-client-electron/service/utils"
"time"
)
var (
LastAwake = time.Now()
listeners = set.NewSet()
)
type Event struct {
Id string `json:"id"`
Type string `json:"type"`
Data interface{} `json:"data"`
}
func (e *Event) Init() {
e.Id = utils.Uuid()
for listInf := range listeners.Iter() {
list := listInf.(*Listener)
go func() {
defer func() {
recover()
}()
list.stream <- e
}()
"github.com/dropbox/godropbox/container/set"
"github.com/gin-gonic/gin"
"github.com/sethgrid/multibar"
"net/http"
"strconv"
"strings"
"sync"
"time"
)
const (
controllerSize = 250
)
var (
hosts = set.NewSet()
hostsLock = sync.Mutex{}
bars []*Bar
barsWaiter sync.WaitGroup
)
type Bar struct {
lock sync.Mutex
setter multibar.ProgressFunc
size int
count int
}
func (b *Bar) Incr() {
b.lock.Lock()
b.count += 1
func init() {
lockedInterfaces = set.NewSet()
}
"ubuntu-yakkety": ".yakkety_",
}
DistroPack = map[string]string{
"archlinux": "pacman",
"fedora": "redhat",
"centos": "redhat",
"debian": "debian",
"ubuntu": "debian",
}
Packagers = [...]string{
"apt",
"pacman",
"yum",
}
ReleasesSet = set.NewSet()
Distros = []string{}
DistrosSet = set.NewSet()
DistroPackager = map[string]string{}
PackagersSet = set.NewSet()
)
func init() {
for _, release := range Releases {
ReleasesSet.Add(release)
distro := strings.Split(release, "-")[0]
Distros = append(Distros, distro)
DistrosSet.Add(distro)
}
for _, distro := range Distros {
func newMockPool() *mockPool {
return &mockPool{
registered: set.NewSet(),
}
}