func main() {
pflag.Parse()
viper.SetConfigName("config")
viper.AddConfigPath(".")
if debug {
logrus.SetLevel(logrus.DebugLevel)
}
if err := viper.ReadInConfig(); err != nil {
logrus.Fatal(err)
}
nick := viper.GetString("twitch.nick")
pass := viper.GetString("twitch.pass")
channels := viper.GetStringSlice("twitch.join")
dbFilename := viper.GetString("database.filename")
superusers := viper.GetStringSlice("permissions.superusers")
bot := bot.NewBot(nick, pass, channels, dbFilename, superusers)
if err := bot.Start(); err != nil {
logrus.Fatal(err)
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
fmt.Print("\r\r\b")
if err := bot.Stop(); err != nil {
logrus.Fatal(err)
}
}
func main() {
startTime := currentTimeMillis()
transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
transport, err := thrift.NewTSocket(NETWORK_ADDR)
if err != nil {
logrus.Fatal(os.Stderr, "error resolving address:", err)
}
useTransport := transportFactory.GetTransport(transport)
client := rpc.NewSessionManagerClientFactory(useTransport, protocolFactory)
if err := transport.Open(); err != nil {
logrus.Fatal(os.Stderr, "Error opening socket to "+NETWORK_ADDR, err)
}
defer transport.Close()
// 开始调用服务的接口
ctx := rpc.NewSessionContext()
sid, _ := client.CreateSession(ctx)
logrus.Infof("创新新的会话id => %s", sid)
ctx, _ = client.GetSession(sid)
logrus.Infof("获取会话上下文 => %+v", ctx)
endTime := currentTimeMillis()
logrus.Infof("本次调用用时: %d 毫秒", endTime-startTime)
}
func join(c *cli.Context) {
dflag := getDiscovery(c)
if dflag == "" {
log.Fatalf("discovery required to join a cluster. See '%s join --help'.", c.App.Name)
}
addr := c.String("advertise")
if addr == "" {
log.Fatal("missing mandatory --advertise flag")
}
if !checkAddrFormat(addr) {
log.Fatal("--advertise should be of the form ip:port or hostname:port")
}
joinDelay, err := time.ParseDuration(c.String("delay"))
if err != nil {
log.Fatalf("invalid --delay: %v", err)
}
if joinDelay < time.Duration(0)*time.Second {
log.Fatalf("--delay should not be a negative number")
}
hb, err := time.ParseDuration(c.String("heartbeat"))
if err != nil {
log.Fatalf("invalid --heartbeat: %v", err)
}
if hb < 1*time.Second {
log.Fatal("--heartbeat should be at least one second")
}
ttl, err := time.ParseDuration(c.String("ttl"))
if err != nil {
log.Fatalf("invalid --ttl: %v", err)
}
if ttl <= hb {
log.Fatal("--ttl must be strictly superior to the heartbeat value")
}
d, err := discovery.New(dflag, hb, ttl, getDiscoveryOpt(c))
if err != nil {
log.Fatal(err)
}
// if joinDelay is 0, no delay will be executed
// if joinDelay is larger than 0,
// add a random delay between 0s and joinDelay at start to avoid synchronized registration
if joinDelay > 0 {
r := rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
delay := time.Duration(r.Int63n(int64(joinDelay)))
log.Infof("Add a random delay %s to avoid synchronized registration", delay)
time.Sleep(delay)
}
for {
log.WithFields(log.Fields{"addr": addr, "discovery": dflag}).Infof("Registering on the discovery service every %s...", hb)
if err := d.Register(addr); err != nil {
log.Error(err)
}
time.Sleep(hb)
}
}
func before(c *cli.Context) error {
initLogFormatter()
initHelpAndVersionFlags()
initAppHelpTemplate()
// Log level
if logLevel, err := log.ParseLevel(c.String(LogLevelKey)); err != nil {
log.Fatal("[BITRISE_CLI] - Failed to parse log level:", err)
} else {
log.SetLevel(logLevel)
}
// Befor parsing cli, and running command
// we need to decide wich path will be used by envman
envman.CurrentEnvStoreFilePath = c.String(PathKey)
if envman.CurrentEnvStoreFilePath == "" {
if path, err := envStorePathInCurrentDir(); err != nil {
log.Fatal("[ENVMAN] - Failed to set envman work path in current dir:", err)
} else {
envman.CurrentEnvStoreFilePath = path
}
}
envman.ToolMode = c.Bool(ToolKey)
if envman.ToolMode {
log.Info("[ENVMAN] - Tool mode on")
}
if _, err := envman.GetConfigs(); err != nil {
log.Fatal("[ENVMAN] - Failed to init configs:", err)
}
return nil
}
func decompress() {
log.Info("Decompressing Riak Explorer")
var err error
if err := os.Mkdir("riak_explorer", 0777); err != nil {
log.Fatal("Unable to make rex directory: ", err)
}
asset, err := artifacts.Asset("trusty.tar.gz")
if err != nil {
log.Fatal(err)
}
if err = common.ExtractGZ("riak_explorer", bytes.NewReader(asset)); err != nil {
log.Fatal("Unable to extract trusty root: ", err)
}
asset, err = artifacts.Asset("riak_explorer-bin.tar.gz")
if err != nil {
log.Fatal(err)
}
if err = common.ExtractGZ("riak_explorer", bytes.NewReader(asset)); err != nil {
log.Fatal("Unable to extract rex: ", err)
}
}
func main() {
err := jq.Init()
if err != nil {
log.Fatal(err)
}
log.WithFields(log.Fields{
"version": jq.Version,
"path": jq.Path,
}).Info("initialized jq")
conf, err := config.Load()
if err != nil {
log.Fatal(err)
}
log.WithFields(log.Fields{
"host": conf.Host,
"port": conf.Port,
}).Infof("Starting server at %s:%s", conf.Host, conf.Port)
srv := server.New(conf)
err = srv.Start()
if err != nil {
log.WithError(err).Fatal("error starting sever")
}
}
func add(c *cli.Context) {
log.Debugln("[ENVMAN] - Work path:", envman.CurrentEnvStoreFilePath)
key := c.String(KeyKey)
expand := !c.Bool(NoExpandKey)
replace := !c.Bool(AppendKey)
var value string
if stdinValue != "" {
value = stdinValue
} else if c.IsSet(ValueKey) {
value = c.String(ValueKey)
} else if c.String(ValueFileKey) != "" {
if v, err := loadValueFromFile(c.String(ValueFileKey)); err != nil {
log.Fatal("[ENVMAN] - Failed to read file value: ", err)
} else {
value = v
}
}
if err := addEnv(key, value, expand, replace); err != nil {
log.Fatal("[ENVMAN] - Failed to add env:", err)
}
log.Debugln("[ENVMAN] - Env added")
if err := logEnvs(); err != nil {
log.Fatal("[ENVMAN] - Failed to print:", err)
}
}
func logoutRegistry(ctx *cobra.Command, args []string) {
reg := client.INDEX_SERVER
if len(args) > 0 {
reg = args[0]
}
config, err := client.LoadConfig(configPath)
if err != nil {
log.Fatal(err)
}
registry, notFound := config.GetRegistry(reg)
if (notFound != nil) || (registry.Credentials == "") {
log.Fatalf("Not logged in to a Docker registry at %s", reg)
}
config.LogoutRegistry(reg)
if err := config.SaveConfig(configPath); err != nil {
log.Fatal(err)
}
ctx.Printf("Removed login credentials for a Docker registry at %s\n\n", reg)
listRegistries(ctx, args)
}
func main() {
log.Info("Starting rancher-metadata")
parseFlags()
err := loadAnswers()
if err != nil {
log.Fatal("Cannot startup without a valid Answers file")
}
watchSignals()
router.HandleFunc("/favicon.ico", http.NotFound)
router.HandleFunc("/", root).
Methods("GET", "HEAD").
Name("Root")
for _, version := range versions {
router.HandleFunc("/{version:"+version+"}", metadata).
Methods("GET", "HEAD").
Name("Version:" + version)
router.HandleFunc("/{version:"+version+"}/{key:.*}", metadata).
Methods("GET", "HEAD").
Name("Metadata")
}
log.Info("Listening on ", *listen)
log.Fatal(http.ListenAndServe(*listen, router))
}
func procesImage(path string, f os.FileInfo, err error) error {
if f.IsDir() {
return nil
}
log.Debugf("Processing %s", path)
extension := filepath.Ext(f.Name())
if !isSupportPhotoType(strings.ToLower(extension)) {
log.Warnf("%s's file type %s is unsupported", path, extension)
return nil
}
reader := exif.New()
err = reader.Open(path)
if err != nil {
log.Fatal(err)
}
str := fmt.Sprintf("%s", reader.Tags["Date and Time"])
t := f.ModTime()
if len(str) == 0 {
log.Warnf("Date and Time EXIF tag missing for %s", path)
} else {
layout := "2006:01:02 15:04:05"
t, err = time.Parse(layout, str)
if err != nil {
log.Fatal(err)
}
}
newDir := fmt.Sprintf("%s/%4d/%02d/%02d", destPath, t.Year(), t.Month(), t.Day())
err = os.MkdirAll(newDir, 0777)
if err != nil {
log.Fatal(err)
}
newFile := fmt.Sprintf("%s/%s", newDir, f.Name())
if mode == "move" {
log.Debugf("Moving %s %s", path, newFile)
err = os.Rename(path, newFile)
} else {
if _, err := os.Stat(newFile); err == nil {
log.Warnf("Photo %s already exists", newFile)
} else {
log.Debugf("Copying %s %s", path, newFile)
err = copyFile(path, newFile)
}
}
if err != nil {
log.Fatal(err)
}
return nil
}
func switchHost(ctx *cobra.Command, args []string) {
if len(args) < 1 {
ErrorExit(ctx, "Needs an argument <NAME> to switch")
}
name := args[0]
config, err := client.LoadConfig(configPath)
if err != nil {
log.Fatal(err)
}
host, err := config.GetHost(name)
if err != nil {
log.Fatal(err)
}
config.Default = host.Name
if err := config.SaveConfig(configPath); err != nil {
log.Fatal(err)
}
listHosts(ctx, args)
}
func (m *Mesos) loadFromMaster(ip string, port string) (sj state.State) {
url := "http://" + ip + ":" + port + "/master/state.json"
req, err := http.NewRequest("GET", url, nil)
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
err = json.Unmarshal(body, &sj)
if err != nil {
log.Fatal(err)
}
return sj
}
func (exp *exporter) main(c *cli.Context) {
setupLogging(c)
registry := newRegistry()
collector, err := exp.Init(c, registry)
if err != nil {
log.Fatal(err)
}
if exp.Tick {
collector.Collect(registry)
interval := c.Int("interval")
go func() {
for _ = range time.Tick(time.Duration(interval) * time.Second) {
if exp.ResetOnTick {
registry.Reset()
}
collector.Collect(registry)
}
}()
}
http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
w.Header().Add("Location", exp.MetricsPath)
w.WriteHeader(http.StatusFound)
})
http.Handle(exp.MetricsPath, prometheus.Handler())
if err := http.ListenAndServe(fmt.Sprintf(":%d", c.Int("port")), nil); err != nil {
log.Fatal(err)
}
}
// DeleteTestRun will remove an entire testrun entry from teh agent cache by UUID
func (ac AgentCache) DeleteTestRun(uuid string) error {
// Open connection
db, err := sql.Open("sqlite3", ac.db_loc)
if err != nil {
log.Error(err)
return errors.New("Error accessing sqlite cache for DeleteTestRun")
}
defer db.Close()
// Begin Update
tx, err := db.Begin()
if err != nil {
log.Fatal(err)
return errors.New("Error beginning new DeleteTestRun action")
}
stmt, err := tx.Prepare(fmt.Sprintf("delete from testruns where uuid = \"%s\" ", uuid))
if err != nil {
log.Fatal(err)
return errors.New("Error preparing new DeleteTestRun action")
}
defer stmt.Close()
_, err = stmt.Exec()
if err != nil {
log.Fatal(err)
return errors.New("Error executing new DeleteTestRun action")
}
tx.Commit()
return nil
}
func main() {
log.Info("starting NNTP server...")
conf, err := config.Ensure("settings.json")
if err != nil {
log.Fatal(err)
}
if conf.Log == "debug" {
log.SetLevel(log.DebugLevel)
}
serv := &nntp.Server{
Config: conf.NNTP,
Feeds: conf.Feeds,
}
serv.Storage, err = store.NewFilesytemStorage(conf.Store.Path, false)
if err != nil {
log.Fatal(err)
}
l, err := net.Listen("tcp", conf.NNTP.Bind)
if err != nil {
log.Fatal(err)
}
log.Info("listening on ", l.Addr())
err = serv.Serve(l)
if err != nil {
log.Fatal(err)
}
}
// Create a new RPC server
func NewRpcServer(portNo uint16) (*rpc.Server, net.Listener) {
server := rpc.NewServer()
// Listens on a port
l, e := net.Listen("tcp", fmt.Sprintf(":%d", portNo))
if e != nil {
log.Fatal("listen error:", e)
}
log.Infof("RPC Server is listening on %s\n", l.Addr())
// run in background
go func() {
for {
conn, err := l.Accept()
if err != nil {
// if listener closed, just exit the groutine
if strings.Contains(err.Error(), "use of closed network connection") {
return
}
log.Fatal(err)
}
log.Infof("Server accepted connection to %s from %s\n", conn.LocalAddr(), conn.RemoteAddr())
go server.ServeCodec(jsonrpc.NewServerCodec(conn))
}
}()
return server, l
}
func main() {
flag.Parse()
if *NAME == "" {
log.Fatal("name required")
}
if *MEMORY == 0 {
log.Fatal("memory required")
}
if *CPUS == 0 {
log.Fatal("cpus required")
}
db, err := bolt.Open(*DB_PATH, 0600, nil)
if err != nil {
log.WithError(err).Fatal("failed to open database")
}
planrep := dal.NewBoltPlanrep(db)
plan := &models.Plan{
Name: *NAME,
Memory: *MEMORY * 1024 * 1024,
Cpus: *CPUS,
DiskSize: *DISK * 1024 * 1024 * 1024,
}
if err := planrep.Add(plan); err != nil {
log.WithError(err).WithField("plan", plan).Fatal("failed to add ip address")
}
}
func SetEnv() {
flag.Parse()
if *debug {
log.SetLevel(log.DebugLevel)
}
if *logFile != "" {
if output, err := os.OpenFile(*logFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666); err != nil {
log.Fatalf("Failed to log to file %s: %v", *logFile, err)
} else {
log.SetOutput(output)
}
}
textFormatter := &log.TextFormatter{
FullTimestamp: true,
}
log.SetFormatter(textFormatter)
if *catalogUrl == "" {
err := "Halting Catalog service, Catalog github repo url not provided"
log.Fatal(err)
fmt.Errorf(err)
}
// Shutdown when parent dies
if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_PDEATHSIG, uintptr(syscall.SIGTERM), 0); err != 0 {
log.Fatal("Failed to set parent death sinal, err")
}
}
func main() {
flag.Parse()
m := methodMap[*method]
db, err := gorm.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True")
if err != nil {
logrus.Fatal("Database open error: ", err)
}
if err := db.DB().Ping(); err != nil {
logrus.Fatal("Database ping error: ", err)
}
db.SingularTable(true)
db.DropTable(&TestTable{})
panicOnError(db.AutoMigrate(&TestTable{}).Error)
c := int64(*iterNum * *goNum)
panicOnError(db.Save(&TestTable{Counter: c}).Error)
logrus.Infof("Initial counter state: %d", c)
logrus.Infof("Number of decrements per goroutine: %d", *iterNum)
logrus.Infof("Number of goroutines: %d", *goNum)
logrus.Infof("Method: %s", *method)
logrus.Infof("Method description:\n%s", strings.TrimSpace(methodDoc[*method]))
done := make(chan bool)
for i := 0; i < *goNum; i++ {
go m(&db, *iterNum, done)
}
for i := 0; i < *goNum; i++ {
<-done
}
var tt TestTable
panicOnError(db.First(&tt, 1).Error)
logrus.Infof("Result: %d", tt.Counter)
}
func init() {
err := envconfig.Process("HELEN", &Constants)
if err != nil {
logrus.Fatal(err)
}
if Constants.SteamDevAPIKey == "" {
logrus.Warning("Steam api key not provided, setting SteamApiMockUp to true")
}
if Constants.PublicAddress == "" {
Constants.PublicAddress = "http://" + Constants.ListenAddress
}
if Constants.MockupAuth {
logrus.Warning("Mockup authentication enabled.")
}
_, err = url.Parse(Constants.PublicAddress)
if err != nil {
logrus.Fatal("Couldn't parse HELEN_PUBLIC_ADDR - ", err)
}
_, err = url.Parse(Constants.LoginRedirectPath)
if err != nil {
logrus.Fatal("Couldn't parse HELEN_SERVER_REDIRECT_PATH - ", err)
}
if Constants.GeoIP {
logrus.Info("GeoIP support enabled")
}
}
func runImport(c *cli.Context) {
var input io.ReadCloser
var err error
input = os.Stdin
cfg, err := config.LoadConfig()
if err != nil {
log.Fatal(err)
}
inputFile := c.String("input")
if inputFile != "" {
input, err = os.Open(inputFile)
if err != nil {
log.Fatal(err)
}
defer input.Close()
}
bytes, err := ioutil.ReadAll(input)
if err != nil {
log.Fatal(err)
}
cfg, err = cfg.Import(bytes)
if err != nil {
log.Fatal(err)
}
if err := cfg.Save(); err != nil {
log.Fatal(err)
}
}
//passwordPrompt prompts user to enter password twice and that the two entries are equivalent.
func passwordPrompt() string {
fmt.Print("Enter password: "******"\nCould not read password:"******"\nConfirm password: "******"\nCould Not read password.")
log.Fatal(errs)
os.Exit(1)
}
if reflect.DeepEqual(password, passwordConfirm) == false {
fmt.Println("\n")
log.Fatal("Passwords do not match")
}
return strings.TrimSpace(string(password))
}
func ConnectRPC(amqpConn *amqp.Connection) {
if !*paulingDisabled {
codec, err := amqprpc.NewClientCodec(amqpConn, config.Constants.PaulingQueue, amqprpc.JSONCodec{})
if err != nil {
logrus.Fatal(err)
}
pauling = rpc.NewClientWithCodec(codec)
}
if !*fumbleDisabled {
codec, err := amqprpc.NewClientCodec(amqpConn, config.Constants.FumbleQueue, amqprpc.JSONCodec{})
if err != nil {
logrus.Fatal(err)
}
fumble = rpc.NewClientWithCodec(codec)
}
if !*twitchbotDisabled {
codec, err := amqprpc.NewClientCodec(amqpConn, config.Constants.TwitchBotQueue, amqprpc.JSONCodec{})
if err != nil {
logrus.Fatal(err)
}
twitchbot = rpc.NewClientWithCodec(codec)
}
}
func (this *App) Run() {
apiServer := rest.NewApi()
apiServer.Use(rest.DefaultDevStack...)
// Cors
apiServer.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
OriginValidator: func(origin string, request *rest.Request) bool {
return true
},
AllowedMethods: []string{"GET", "POST", "PUT"},
AllowedHeaders: []string{
"Authorization", "Accept", "Content-Type", "X-Custom-Header", "Origin",
},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 3600,
})
// Jsonp
apiServer.Use(&rest.JsonpMiddleware{
CallbackNameKey: "jsonp",
})
router, err := rest.MakeRouter(config.Routes...)
if err != nil {
log.Fatal(err)
}
apiServer.SetApp(router)
log.Info("Start serving, port=", this.Env.Port)
log.Fatal(http.ListenAndServe(this.Port(), apiServer.MakeHandler()))
}
func main() {
flag.Parse()
log.SetOutput(os.Stdout)
log.SetLevel(log.DebugLevel)
var client *docker.Client
if os.Getenv("DOCKER_HOST") != "" {
var err error
certPath := os.Getenv("DOCKER_CERT_PATH")
client, err = docker.NewTLSClient(os.Getenv("DOCKER_HOST"), path.Join(certPath, "cert.pem"), path.Join(certPath, "key.pem"), path.Join(certPath, "ca.pem"))
if err != nil {
log.Fatal(err)
}
} else {
var err error
client, err = docker.NewClient("unix:///var/run/docker.sock")
if err != nil {
log.Fatal(err)
}
}
handler := Handler{docker: client, domain: fmt.Sprintf("%s.", *domain)}
server := dns.Server{}
server.Handler = &handler
server.Net = *network
server.Addr = *addr
err := server.ListenAndServe()
if err != nil {
log.Fatal(err)
}
}
func storagepoolAgent(c *cli.Context) {
healthCheckInterval := c.GlobalInt("healthcheck-interval")
healthCheckBaseDir := c.GlobalString("healthcheck-basedir")
healthCheckType := c.String("storagepool-healthcheck-type")
cattleUrl := c.GlobalString("url")
cattleAccessKey := c.GlobalString("access-key")
cattleSecretKey := c.GlobalString("secret-key")
if c.GlobalBool("debug") {
log.SetLevel(log.DebugLevel)
}
storagepoolRootDir := c.GlobalString("storagepool-rootdir")
driver := c.GlobalString("storagepool-driver")
if driver == "" {
log.Fatal("required field storagepool-driver has not been set")
}
cattleClient, err := cattle.NewCattleClient(cattleUrl, cattleAccessKey, cattleSecretKey)
if err != nil {
log.Fatal(err)
}
storagepoolAgent := NewStoragepoolAgent(healthCheckInterval, storagepoolRootDir, driver, healthCheckBaseDir, healthCheckType, cattleClient)
metadataUrl := c.String("storagepool-metadata-url")
if err := storagepoolAgent.Run(metadataUrl); err != nil {
log.Fatal(err)
}
}
func enable(c *cli.Context) {
changed := false
cfg, err := config.LoadConfig()
if err != nil {
log.Fatal(err)
}
for _, service := range c.Args() {
if val, ok := cfg.Rancher.ServicesInclude[service]; !ok || !val {
if strings.HasPrefix(service, "/") && !strings.HasPrefix(service, "/var/lib/rancher/conf") {
log.Fatalf("ERROR: Service should be in path /var/lib/rancher/conf")
}
if _, err := compose.LoadServiceResource(service, true, cfg); err != nil {
log.Fatalf("could not load service %s", service)
}
cfg.Rancher.ServicesInclude[service] = true
changed = true
}
}
if changed {
if err := cfg.Set("rancher.services_include", cfg.Rancher.ServicesInclude); err != nil {
log.Fatal(err)
}
}
}
// Read the snapd configuration from a configuration file
func readConfig(cfg *Config, fpath string) {
var path string
if !defaultConfigFile() && fpath == "" {
return
}
if defaultConfigFile() && fpath == "" {
path = defaultConfigPath
}
if fpath != "" {
f, err := os.Stat(fpath)
if err != nil {
log.Fatal(err)
}
if f.IsDir() {
log.Fatal("configuration path provided must be a file")
}
path = fpath
}
serrs := cfgfile.Read(path, &cfg, CONFIG_CONSTRAINTS)
if serrs != nil {
for _, serr := range serrs {
log.WithFields(serr.Fields()).Error(serr.Error())
}
log.Fatal("Errors found while parsing global configuration file")
}
}
func main() {
f, err := os.OpenFile("server0.log", os.O_APPEND|os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
fmt.Printf("error opening file: %v", err)
}
// don't forget to close it
defer f.Close()
log.SetOutput(f)
log.SetLevel(log.DebugLevel)
globalData, err := platform.CreateGlobalData()
if err != nil {
log.Fatal(err)
return
}
runtime.GOMAXPROCS(runtime.NumCPU())
c, err := service.NewContester("server.ini", globalData)
if err != nil {
log.Fatal(err)
return
}
rpc.Register(c)
for {
if err = rpc4go.ConnectServer(c.ServerAddress, rpc.DefaultServer); err != nil {
log.Error(err)
time.Sleep(time.Second * 5)
}
}
}
func ProjectPort(p *project.Project, c *cli.Context) {
if len(c.Args()) != 2 {
logrus.Fatalf("Please pass arguments in the form: SERVICE PORT")
}
index := c.Int("index")
protocol := c.String("protocol")
service, err := p.CreateService(c.Args()[0])
if err != nil {
logrus.Fatal(err)
}
containers, err := service.Containers()
if err != nil {
logrus.Fatal(err)
}
if index < 1 || index > len(containers) {
logrus.Fatalf("Invalid index %d", index)
}
output, err := containers[index-1].Port(fmt.Sprintf("%s/%s", c.Args()[1], protocol))
if err != nil {
logrus.Fatal(err)
}
fmt.Println(output)
}