示例#1
0
文件: droplets.go 项目: aybabtme/doit
// Backups returns a list of backup images for a droplet.
func DropletBackups(c *cli.Context) {
	client := NewClient(c, DefaultConfig)
	id := c.Int(ArgDropletID)
	opts := LoadOpts(c)

	f := func(opt *godo.ListOptions) ([]interface{}, *godo.Response, error) {
		list, resp, err := client.Droplets.Backups(id, opt)
		if err != nil {
			return nil, nil, err
		}

		si := make([]interface{}, len(list))
		for i := range list {
			si[i] = list[i]
		}

		return si, resp, err
	}

	si, err := PaginateResp(f, opts)
	if err != nil {
		logrus.WithField("err", err).Fatal("could not list backups for droplet")
	}

	list := make([]godo.Image, len(si))
	for i := range si {
		list[i] = si[i].(godo.Image)
	}

	err = displayOutput(c, list)
	if err != nil {
		logrus.WithField("err", err).Fatal("could not write output")
	}
}
// NewDriver creates a new MACVLAN Driver
func NewDriver(version string, ctx *cli.Context) (*Driver, error) {
	docker, err := dockerclient.NewDockerClient("unix:///var/run/docker.sock", nil)
	if err != nil {
		return nil, fmt.Errorf("could not connect to docker: %s", err)
	}
	// lower bound of v4 MTU is 68-bytes per rfc791
	if ctx.Int("mtu") <= 0 {
		cliMTU = defaultMTU
	} else if ctx.Int("mtu") >= minMTU {
		cliMTU = ctx.Int("mtu")
	} else {
		log.Fatalf("The MTU value passed [ %d ] must be greater than [ %d ] bytes per rfc791", ctx.Int("mtu"), minMTU)
	}
	// Set the default mode to bridge
	if ctx.String("mode") == "" {
		macvlanMode = bridgeMode
	}
	switch ctx.String("mode") {
	case bridgeMode:
		macvlanMode = bridgeMode
		// todo: in other modes if relevant
	}
	d := &Driver{
		networks: networkTable{},
		dockerer: dockerer{
			client: docker,
		},
	}
	return d, nil
}
示例#3
0
文件: main.go 项目: gernest/apidemic
func server(ctx *cli.Context) {
	port := ctx.Int("port")
	s := apidemic.NewServer()

	log.Println("starting server on port :", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), s))
}
示例#4
0
// FromCLIContext creates a Config using a cli.Context by pulling configuration
// from the flags in the context.
func FromCLIContext(c *cli.Context) *Config {
	cfg := &Config{}
	cfgVal := reflect.ValueOf(cfg).Elem()

	for _, def := range defs {
		if !def.HasField {
			continue
		}

		field := cfgVal.FieldByName(def.FieldName)

		if _, ok := def.Flag.(*cli.BoolFlag); ok {
			field.SetBool(c.Bool(def.Name))
		} else if _, ok := def.Flag.(*cli.DurationFlag); ok {
			field.Set(reflect.ValueOf(c.Duration(def.Name)))
		} else if _, ok := def.Flag.(*cli.IntFlag); ok {
			field.SetInt(int64(c.Int(def.Name)))
		} else if _, ok := def.Flag.(*cli.StringFlag); ok {
			field.SetString(c.String(def.Name))
		}
	}

	cfg.ProviderConfig = ProviderConfigFromEnviron(cfg.ProviderName)

	return cfg
}
示例#5
0
func health(c *cli.Context) {
	endpoint := c.String("e")
	requests := c.Int("r")

	done := make(chan bool)
	var healthy uint64 = 0

	for i := 0; i < requests; i++ {
		go func() {
			resp, err := http.Get("http://" + endpoint + "/health")
			if err != nil {
				fmt.Printf("ERROR: %v\n", err)
			} else {
				fmt.Printf("Response: %v\n", resp.Status)

				if resp.StatusCode == 200 {
					atomic.AddUint64(&healthy, 1)
					runtime.Gosched()
				}
			}
			done <- true
		}()
	}

	for i := 0; i < requests; i++ {
		<-done
	}
	fmt.Printf("Healthy Requests: %v\n", atomic.LoadUint64(&healthy))
}
示例#6
0
func createNetwork(ctx *cli.Context) {
	argCheck(1, ctx)

	subnet := ctx.String("subnet")
	gateway := ctx.String("gateway")

	if subnet == "" || gateway == "" {
		errExit(ctx, exitHelp, "Invalid Arguments", true)
	}

	tenant := ctx.String("tenant")
	network := ctx.Args()[0]
	encap := ctx.String("encap")
	pktTag := ctx.Int("pkt-tag")

	url := fmt.Sprintf("%s%s:%s/", networkURL(ctx), tenant, network)

	out := map[string]interface{}{
		"tenantName":  tenant,
		"networkName": network,
		"encap":       encap,
		"pktTag":      pktTag,
		"subnet":      subnet,
		"gateway":     gateway,
	}

	postMap(ctx, url, out)
}
示例#7
0
func getMetric(ctx *cli.Context) error {
	if !ctx.IsSet("metric-namespace") {
		return newUsageError("namespace is required\n\n", ctx)
	}
	ns := ctx.String("metric-namespace")
	ver := ctx.Int("metric-version")
	metric := pClient.GetMetric(ns, ver)
	switch mtype := metric.(type) {
	case []*client.GetMetricResult:
		// Multiple metrics
		var merr error
		for i, m := range metric.([]*client.GetMetricResult) {
			err := printMetric(m, i)
			if err != nil {
				merr = err
			}
		}
		if merr != nil {
			return merr
		}
	case *client.GetMetricResult:
		// Single metric
		err := printMetric(metric.(*client.GetMetricResult), 0)
		if err != nil {
			return err
		}
	default:
		return fmt.Errorf("Unexpected response type %T\n", mtype)
	}
	return nil
}
示例#8
0
// Populate updates the specified project context based on command line arguments and subcommands.
func Populate(context *project.Context, c *cli.Context) {
	context.ComposeFiles = c.GlobalStringSlice("file")

	if len(context.ComposeFiles) == 0 {
		context.ComposeFiles = []string{"docker-compose.yml"}
		if _, err := os.Stat("docker-compose.override.yml"); err == nil {
			context.ComposeFiles = append(context.ComposeFiles, "docker-compose.override.yml")
		}
	}

	context.ProjectName = c.GlobalString("project-name")

	if c.Command.Name == "logs" {
		context.Log = true
		context.FollowLog = c.Bool("follow")
	} else if c.Command.Name == "up" || c.Command.Name == "create" {
		context.Log = !c.Bool("d")
		context.NoRecreate = c.Bool("no-recreate")
		context.ForceRecreate = c.Bool("force-recreate")
		context.NoBuild = c.Bool("no-build")
	} else if c.Command.Name == "stop" || c.Command.Name == "restart" || c.Command.Name == "scale" {
		context.Timeout = uint(c.Int("timeout"))
	} else if c.Command.Name == "kill" {
		context.Signal = c.String("signal")
	} else if c.Command.Name == "rm" {
		context.Volume = c.Bool("v")
	} else if c.Command.Name == "build" {
		context.NoCache = c.Bool("no-cache")
	}
}
示例#9
0
文件: actions.go 项目: anarcher/s3cli
func GetAction(c *cli.Context) {
	if len(c.Args()) != 2 {
		log.Fatal("get s3path localpath")
	}

	s3path, err := NewS3Path(c.Args().Get(0))
	if err != nil {
		log.Fatal(err)
	}

	localpath := c.Args().Get(1)
	if localpath == "" {
		log.Fatal("get s3path localpath")
	}

	log.Printf("s3path Bucket:%v Prefix:%v", s3path.Bucket, s3path.Prefix)
	parallel := c.Int("parallel")

	manager := s3manager.NewDownloader(nil)
	d := NewDownloader(s3path, localpath, parallel, manager)

	client := s3.New(nil)
	params := &s3.ListObjectsInput{Bucket: &s3path.Bucket, Prefix: &s3path.Prefix}
	err = client.ListObjectsPages(params, d.eachPage)
	if err != nil {
		log.Fatal(err)
	}
	d.Wait()
}
示例#10
0
文件: list.go 项目: Cretezy/fddp
func ListAction(c *cli.Context) {
	// Figure out input
	if len(c.Args()) < 1 {
		cli.ShowCommandHelp(c, c.Command.Name)
		return
	}

	jsonFile := c.Args()[0]

	data := FromJSON(GetFileContent(jsonFile))

	count := c.Int("count")

	threads := data.Threads

	if count > len(threads) {
		count = len(threads)
	}

	// Sort by message count
	sort.Sort(ByMessage(threads))

	// Reverse (top = more)
	for i, j := 0, len(threads)-1; i < j; i, j = i+1, j-1 {
		threads[i], threads[j] = threads[j], threads[i]
	}

	threads = threads[:count]

	for _, thread := range threads {
		fmt.Println(strings.Join(DeleteElementFromSlice(thread.Persons, data.WhoAmI), ", ")+" > Messages:", thread.CountMessages(), "Words:", thread.CountWords())
	}
}
示例#11
0
文件: server.go 项目: kamito/c3h8
func RunServer(c *cli.Context) *Server {
	s := new(Server)
	s.Host = c.String("bind-addr")
	s.Port = c.Int("port")
	s.Run()
	return s
}
示例#12
0
// ServerFromCli uses the cli arguments to configure a server instance
func ServerFromCli(c *cli.Context) *gouncer.Server {
	CheckSSL(c)

	// Initialize configuration components from cli
	core := &gouncer.Core{c.String("hostname"), ":" + c.String("port"), c.Bool("jsonp"), c.String("log")}
	ssl := &gouncer.Ssl{c.String("certificate"), c.String("key")}

	backend := &gouncer.Backend{
		Couchdb:  c.String("couchdb"),
		Userdb:   c.String("userdb"),
		Groupdb:  c.String("groupdb"),
		Memcache: c.StringSlice("memcache"),
		Smtp:     c.String("smtp"),
	}

	token := &gouncer.Token{c.String("algorithm"), int32(c.Int("expiration"))}

	// Create configuration
	cfg := &gouncer.Config{
		Core:    core,
		Ssl:     ssl,
		Backend: backend,
		Token:   token,
	}

	return gouncer.NewServer(cfg)
}
示例#13
0
// delete containers which are not running
func removeContainers(c *cli.Context) {
	dry := c.Bool("dry")
	exited := c.Bool("exited")
	hours := c.Int("hours")

	if !exited {
		cli.ShowCommandHelp(c, "rm")
		fmt.Println("EXAMPLE:")
		fmt.Println("   command rm --exited")
		return
	}
	if hours <= 0 {
		hours = 24
	}

	ctx := getUtilContext()
	if ctx == nil {
		return
	}

	if exited == true {
		ctx.DeleteExitedContainers(dry, hours)
	}

	return
}
示例#14
0
// log.fatalf will block the process and return errors. so the errors.new can be remove, or fmt.Errorf(). fmz.
// when no param pass, it will not equal "", because i set the value(default) first, fmz.
func ParseParam(ctx *cli.Context) error {
	if ctx.String("host-interface") == "" {
		log.Fatalf("Required flag [ host-interface ] is missing")
		return errors.New("Required flag [ host-interface ] is missing")
	}

	CliIF = ctx.String("host-interface")
	if ctx.String("ip") == "" || ctx.String("gateway") == "" || ctx.String("container-name") == "" {
		log.Fatalf("Required flag [ ip or gateway or container-name ] is missing")
		return errors.New("Required flag [ ip or gateway or container-name ] is missing")
	}

	CliIP = ctx.String("ip")
	CligwIP = ctx.String("gateway")
	CliCName = ctx.String("container-name")

	if ctx.Int("mtu") <= 0 {
		CliMTU = CliMTU
	} else if ctx.Int("mtu") >= minMTU {
		CliMTU = ctx.Int("mtu")
	} else {
		log.Fatalf("The MTU value passed [ %d ] must be greater than [ %d ] bytes per rfc791", ctx.Int("mtu"), minMTU)
		return errors.New("the mtu must be int")
	}
	return nil
}
示例#15
0
func cmdRackScale(c *cli.Context) {
	count := 0
	typ := ""

	if c.IsSet("count") {
		count = c.Int("count")
	}

	if c.IsSet("type") {
		typ = c.String("type")
	}

	system, err := rackClient(c).ScaleSystem(count, typ)

	if err != nil {
		stdcli.Error(err)
		return
	}

	fmt.Printf("Name     %s\n", system.Name)
	fmt.Printf("Status   %s\n", system.Status)
	fmt.Printf("Version  %s\n", system.Version)
	fmt.Printf("Count    %d\n", system.Count)
	fmt.Printf("Type     %s\n", system.Type)
}
示例#16
0
文件: scale.go 项目: pmuellr/cli
func (cmd *Scale) Run(c *cli.Context) {
	currentApp := cmd.appReq.GetApplication()
	cmd.ui.Say("Scaling app %s in org %s / space %s as %s...",
		terminal.EntityNameColor(currentApp.Name),
		terminal.EntityNameColor(cmd.config.OrganizationFields.Name),
		terminal.EntityNameColor(cmd.config.SpaceFields.Name),
		terminal.EntityNameColor(cmd.config.Username()),
	)

	params := cf.NewEmptyAppParams()

	if c.String("m") != "" {
		memory, err := formatters.ToMegabytes(c.String("m"))
		if err != nil {
			cmd.ui.Say("Invalid value for memory")
			cmd.ui.FailWithUsage(c, "scale")
			return
		}
		params.Set("memory", memory)
	}

	if c.Int("i") != -1 {
		params.Set("instances", c.Int("i"))
	}

	_, apiResponse := cmd.appRepo.Update(currentApp.Guid, params)
	if apiResponse.IsNotSuccessful() {
		cmd.ui.Failed(apiResponse.Message)
		return
	}

	cmd.ui.Ok()
	cmd.ui.Say("")
}
示例#17
0
func (cmd CreateQuota) Run(context *cli.Context) {
	name := context.Args()[0]

	cmd.ui.Say(T("Creating quota {{.QuotaName}} as {{.Username}}...", map[string]interface{}{
		"QuotaName": terminal.EntityNameColor(name),
		"Username":  terminal.EntityNameColor(cmd.config.Username()),
	}))

	quota := models.QuotaFields{
		Name: name,
	}

	memoryLimit := context.String("m")
	if memoryLimit != "" {
		parsedMemory, err := formatters.ToMegabytes(memoryLimit)
		if err != nil {
			cmd.ui.Failed(T("Invalid memory limit: {{.MemoryLimit}}\n{{.Err}}", map[string]interface{}{"MemoryLimit": memoryLimit, "Err": err}))
		}

		quota.MemoryLimit = parsedMemory
	}

	instanceMemoryLimit := context.String("i")
	if instanceMemoryLimit == "-1" || instanceMemoryLimit == "" {
		quota.InstanceMemoryLimit = -1
	} else {
		parsedMemory, errr := formatters.ToMegabytes(instanceMemoryLimit)
		if errr != nil {
			cmd.ui.Failed(T("Invalid instance memory limit: {{.MemoryLimit}}\n{{.Err}}", map[string]interface{}{"MemoryLimit": instanceMemoryLimit, "Err": errr}))
		}
		quota.InstanceMemoryLimit = parsedMemory
	}

	if context.IsSet("r") {
		quota.RoutesLimit = context.Int("r")
	}

	if context.IsSet("s") {
		quota.ServicesLimit = context.Int("s")
	}

	if context.IsSet("allow-paid-service-plans") {
		quota.NonBasicServicesAllowed = true
	}

	err := cmd.quotaRepo.Create(quota)

	httpErr, ok := err.(errors.HttpError)
	if ok && httpErr.ErrorCode() == errors.QUOTA_EXISTS {
		cmd.ui.Ok()
		cmd.ui.Warn(T("Quota Definition {{.QuotaName}} already exists", map[string]interface{}{"QuotaName": quota.Name}))
		return
	}

	if err != nil {
		cmd.ui.Failed(err.Error())
	}

	cmd.ui.Ok()
}
示例#18
0
func renew(c *cli.Context) {
	conf, _, client := setup(c)

	if len(c.GlobalStringSlice("domains")) <= 0 {
		logger().Fatal("Please specify at least one domain.")
	}

	domain := c.GlobalStringSlice("domains")[0]

	// load the cert resource from files.
	// We store the certificate, private key and metadata in different files
	// as web servers would not be able to work with a combined file.
	certPath := path.Join(conf.CertPath(), domain+".crt")
	privPath := path.Join(conf.CertPath(), domain+".key")
	metaPath := path.Join(conf.CertPath(), domain+".json")

	certBytes, err := ioutil.ReadFile(certPath)
	if err != nil {
		logger().Fatalf("Error while loading the certificate for domain %s\n\t%s", domain, err.Error())
	}

	if c.IsSet("days") {
		expTime, err := acme.GetPEMCertExpiration(certBytes)
		if err != nil {
			logger().Printf("Could not get Certification expiration for domain %s", domain)
		}

		if int(expTime.Sub(time.Now()).Hours()/24.0) > c.Int("days") {
			return
		}
	}

	metaBytes, err := ioutil.ReadFile(metaPath)
	if err != nil {
		logger().Fatalf("Error while loading the meta data for domain %s\n\t%s", domain, err.Error())
	}

	var certRes acme.CertificateResource
	err = json.Unmarshal(metaBytes, &certRes)
	if err != nil {
		logger().Fatalf("Error while marshalling the meta data for domain %s\n\t%s", domain, err.Error())
	}

	if c.Bool("reuse-key") {
		keyBytes, err := ioutil.ReadFile(privPath)
		if err != nil {
			logger().Fatalf("Error while loading the private key for domain %s\n\t%s", domain, err.Error())
		}
		certRes.PrivateKey = keyBytes
	}

	certRes.Certificate = certBytes

	newCert, err := client.RenewCertificate(certRes, true)
	if err != nil {
		logger().Fatalf("%s", err.Error())
	}

	saveCertRes(newCert, conf)
}
示例#19
0
func addRule(ctx *cli.Context) {
	argCheck(2, ctx)

	args := map[string]interface{}{
		"tenantName":    ctx.String("tenant"),
		"policyName":    ctx.Args()[0],
		"ruleId":        ctx.Args()[1],
		"priority":      ctx.Int("priority"),
		"direction":     ctx.String("direction"),
		"endpointGroup": ctx.String("epg"),
		"network":       ctx.String("network"),
		"ipAddress":     ctx.String("ip-address"),
		"protocol":      ctx.String("protocol"),
		"port":          ctx.Int("port"),
		"action":        ctx.String("action"),
	}

	url := fmt.Sprintf(
		"%s%s:%s:%s/",
		ruleURL(ctx),
		args["tenantName"].(string),
		args["policyName"].(string),
		args["ruleId"].(string),
	)

	postMap(ctx, url, args)
}
示例#20
0
func dnsCreate(c *cli.Context) {
	if err := checkEnv(); err != nil {
		fmt.Println(err)
		return
	}
	if err := checkFlags(c, "zone", "name", "type", "content"); err != nil {
		return
	}
	zone := c.String("zone")
	name := c.String("name")
	rtype := c.String("type")
	content := c.String("content")
	ttl := c.Int("ttl")
	proxy := c.Bool("proxy")

	zoneID, err := api.ZoneIDByName(zone)
	if err != nil {
		fmt.Println(err)
		return
	}

	record := cloudflare.DNSRecord{
		Name:    name,
		Type:    strings.ToUpper(rtype),
		Content: content,
		TTL:     ttl,
		Proxied: proxy,
	}
	// TODO: Print the result.
	_, err = api.CreateDNSRecord(zoneID, record)
	if err != nil {
		fmt.Println("Error creating DNS record:", err)
	}
}
示例#21
0
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)
}
示例#22
0
func dnsUpdate(c *cli.Context) {
	if err := checkEnv(); err != nil {
		fmt.Println(err)
		return
	}
	if err := checkFlags(c, "zone", "id"); err != nil {
		return
	}
	zone := c.String("zone")
	recordID := c.String("id")
	content := c.String("content")
	ttl := c.Int("ttl")
	proxy := c.Bool("proxy")

	zoneID, err := api.ZoneIDByName(zone)
	if err != nil {
		fmt.Println(err)
		return
	}

	record := cloudflare.DNSRecord{
		ID:      recordID,
		Content: content,
		TTL:     ttl,
		Proxied: proxy,
	}
	err = api.UpdateDNSRecord(zoneID, recordID, record)
	if err != nil {
		fmt.Println("Error updating DNS record:", err)
	}
}
示例#23
0
func kill(c *cli.Context) {
	endpoint := c.String("e")
	requests := c.Int("r")

	done := make(chan bool)

	for i := 0; i < requests; i++ {
		fmt.Printf("Killing instance %v...\n", i)

		// Use goroutines to kill instances in parallel!
		go func() {
			resp, err := http.Get("http://" + endpoint + "/killSwitch")
			if err != nil {
				fmt.Printf("ERROR: %v\n", err)
			} else {
				fmt.Printf("Response: %v\n", resp.Status)
			}
			done <- true
		}()
	}

	// Allow all goroutines to finish executing.
	for i := 0; i < requests; i++ {
		<-done
	}
}
示例#24
0
func unloadPlugin(ctx *cli.Context) {
	pType := ctx.String("plugin-type")
	pName := ctx.String("plugin-name")
	pVer := ctx.Int("plugin-version")
	if pName == "" {
		fmt.Println("Must provide plugin name")
		cli.ShowCommandHelp(ctx, ctx.Command.Name)
		os.Exit(1)
	}
	if pVer < 1 {
		fmt.Println("Must provide plugin version")
		cli.ShowCommandHelp(ctx, ctx.Command.Name)
		os.Exit(1)
	}

	r := pClient.UnloadPlugin(pType, pName, pVer)
	if r.Err != nil {
		fmt.Printf("Error unloading plugin:\n%v\n", r.Err.Error())
		os.Exit(1)
	}

	fmt.Println("Plugin unloaded")
	fmt.Printf("Name: %s\n", r.Name)
	fmt.Printf("Version: %d\n", r.Version)
	fmt.Printf("Type: %s\n", r.Type)
}
示例#25
0
// createLocalConfig creates a config object that supports local mode.
func createLocalConfig(context *cli.Context) *lib.Config {
	return &lib.Config{
		NativeJobQueueSize:        uint(context.Int("native-job-queue-size")),
		NativePrinterPollInterval: context.String("native-printer-poll-interval"),
		PrefixJobIDToJobTitle:     context.Bool("prefix-job-id-to-job-title"),
		DisplayNamePrefix:         context.String("display-name-prefix"),
		SNMPEnable:                context.Bool("snmp-enable"),
		SNMPCommunity:             context.String("snmp-community"),
		SNMPMaxConnections:        uint(context.Int("snmp-max-connections")),
		PrinterBlacklist:          lib.DefaultConfig.PrinterBlacklist,
		LocalPrintingEnable:       true,
		CloudPrintingEnable:       false,
		LogLevel:                  context.String("log-level"),

		LogFileName:                      context.String("log-file-name"),
		LogFileMaxMegabytes:              uint(context.Int("log-file-max-megabytes")),
		LogMaxFiles:                      uint(context.Int("log-max-files")),
		LogToJournal:                     context.Bool("log-to-journal"),
		MonitorSocketFilename:            context.String("monitor-socket-filename"),
		CUPSMaxConnections:               uint(context.Int("cups-max-connections")),
		CUPSConnectTimeout:               context.String("cups-connect-timeout"),
		CUPSPrinterAttributes:            lib.DefaultConfig.CUPSPrinterAttributes,
		CUPSJobFullUsername:              context.Bool("cups-job-full-username"),
		CUPSIgnoreRawPrinters:            context.Bool("cups-ignore-raw-printers"),
		CUPSIgnoreClassPrinters:          context.Bool("cups-ignore-class-printers"),
		CUPSCopyPrinterInfoToDisplayName: context.Bool("cups-copy-printer-info-to-display-name"),
	}
}
示例#26
0
func doVolumeCreate(c *cli.Context) error {
	var err error

	name := c.Args().First()
	size, err := getSize(c, err)
	driverName, err := util.GetFlag(c, "driver", false, err)
	backupURL, err := util.GetFlag(c, "backup", false, err)
	if err != nil {
		return err
	}

	driverVolumeID := c.String("id")
	volumeType := c.String("type")
	iops := c.Int("iops")
	prepareForVM := c.Bool("vm")

	request := &api.VolumeCreateRequest{
		Name:           name,
		DriverName:     driverName,
		Size:           size,
		BackupURL:      backupURL,
		DriverVolumeID: driverVolumeID,
		Type:           volumeType,
		IOPS:           int64(iops),
		PrepareForVM:   prepareForVM,
		Verbose:        c.GlobalBool(verboseFlag),
	}

	url := "/volumes/create"

	return sendRequestAndPrint("POST", url, request)
}
示例#27
0
func doLbCreate(c *cli.Context) {
	if len(c.Args()) == 0 {
		displayWrongNumOfArgsAndExit(c)
	}
	lbname := c.Args().Get(0)

	path := "/load-balancer"
	if c.Int("subscription-id") > 0 {
		path += "/" + strconv.Itoa(c.Int("subscription-id"))
	}
	path += "/create/" + lbname

	resp, err := client.SendRequest("POST", path, nil)
	assert(err)

	if resp.StatusCode >= 400 {
		displayErrorAndExit(string(resp.Body))
	}

	pwd := lib.PasswordResponse{}
	assert(xml.Unmarshal(resp.Body, &pwd))

	outputResult(c, pwd, func(format string) {
		lib.PrintXMLStruct(pwd)
	})
}
示例#28
0
// Run initializes the driver
func Run(ctx *cli.Context) {

	gitRepoURL := fmt.Sprint(pluginPath, ctx.String("repo"))
	if gitRepoURL == "" {
		log.Fatalf("Exiting: A git URL is required to be used as a shared datastore for the endpoints")
	}
	log.Debugf("The plugin repo is [ %s ]", gitRepoURL)

	gitPollInterval := ctx.Int("poll-interval")
	if gitPollInterval == 0 {
		gitPollInterval = control.DefaultInterval
	}
	log.Debugf("The git polling interval is [ %d ]", gitPollInterval)

	var d ipvlan.Driver
	var err error
	if d, err = ipvlan.New(version, ctx); err != nil {
		log.Fatalf("unable to create driver: %s", err)
	}
	// concatenate the absolute path to the spec file handle
	absSocket := fmt.Sprint(pluginPath, ctx.String("socket"))
	log.Info("IPVlan network driver initialized successfully")
	log.Debugf("The plugin absolute path and handle is [ %s ]", absSocket)
	if err := d.Listen(absSocket); err != nil {
		log.Fatal(err)
	}
}
示例#29
0
func newCassandraDriver(ctx *cli.Context) (drivers.Driver, error) {

	urls := strings.Split(ctx.String("cassandra-hosts"), ",")

	cluster := gocql.NewCluster()
	cluster.Hosts = urls
	cluster.Port = ctx.Int("cassandra-port")
	cluster.Keyspace = ctx.String("cassandra-keyspace")
	cluster.Consistency = gocql.Quorum
	session, err := cluster.CreateSession()

	if err != nil {
		log.Errorf("cassandra.go: Error while creating cassandra cluster: hosts:%v err:%v", cluster.Hosts, err)
		return nil, err
	}

	log.Infoln("cassandra.go: connected to cassandra cluster")

	d := &CassandraDriver{
		Session: session,
		Cluster: cluster,
	}

	return d, nil
}
示例#30
0
func cmdAdd(c *cli.Context) {
	utils.FlagsRequired(c, []string{"cidr", "minPort", "maxPort", "ipProtocol"})

	// API accepts only 1 rule
	newRule := &Rule{
		c.String("ipProtocol"),
		c.String("cidr"),
		c.Int("minPort"),
		c.Int("maxPort"),
	}
	policy := get()

	exists := check(policy, *newRule)

	if exists == false {
		policy.Rules = append(policy.Rules, *newRule)
		webservice, err := webservice.NewWebService()
		utils.CheckError(err)

		nRule := make(map[string]Rule)
		nRule["rule"] = *newRule

		json, err := json.Marshal(nRule)
		utils.CheckError(err)
		err, res, code := webservice.Post(fmt.Sprintf("%s/rules", endpoint), json)
		if res == nil {
			log.Fatal(err)
		}
		utils.CheckError(err)
		utils.CheckReturnCode(code, res)
	}
}