func main() {
optRegion := flag.String("region", "", "AWS Region")
optInstanceID := flag.String("instance-id", "", "Instance ID")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var cpucredit CPUCreditPlugin
if *optRegion == "" || *optInstanceID == "" {
cpucredit.Region = aws.InstanceRegion()
cpucredit.InstanceID = aws.InstanceId()
} else {
cpucredit.Region = *optRegion
cpucredit.InstanceID = *optInstanceID
}
cpucredit.AccessKeyID = *optAccessKeyID
cpucredit.SecretAccessKey = *optSecretAccessKey
helper := mp.NewMackerelPlugin(cpucredit)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-cpucredit"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
var inst_id string
if instanceID == "" {
inst_id := aws.InstanceId()
if inst_id == "unknown" {
log.Fatalln("Unable to get instance id")
}
} else {
inst_id = instanceID
}
auth, err := aws.GetAuth(accesskey, secretkey, "", time.Time{})
if err != nil {
log.Fatalln("Unable to get AWS auth", err)
}
awsec2 = ec2.New(auth, aws.GetRegion(region))
groupMap := getSecurityGroupIds(inst_id)
for _, id := range securityGroupIDs {
groupMap[id] = true
}
groupIds := make([]string, 0, len(groupMap))
for id := range groupMap {
groupIds = append(groupIds, id)
}
opts := &ec2.ModifyInstanceAttributeOptions{SecurityGroups: ec2.SecurityGroupIds(groupIds...)}
resp, err := awsec2.ModifyInstanceAttribute(inst_id, opts)
if err != nil || !resp.Return {
log.Fatalln("Error adding security groups to instance", err)
}
log.Printf("Added security groups %s to instance %s\n", securityGroupIDs.String(), inst_id)
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
// this waits until we get a kill signal
<-c
groupMap = getSecurityGroupIds(inst_id)
for _, id := range securityGroupIDs {
delete(groupMap, id)
}
groupIds = make([]string, 0, len(groupMap))
for id := range groupMap {
groupIds = append(groupIds, id)
}
opts = &ec2.ModifyInstanceAttributeOptions{SecurityGroups: ec2.SecurityGroupIds(groupIds...)}
resp, err = awsec2.ModifyInstanceAttribute(inst_id, opts)
if err != nil || !resp.Return {
log.Fatalln("Error removing security groups from instance", err)
}
log.Printf("Removed security groups %s from instance %s\n", securityGroupIDs.String(), inst_id)
}
func Main() error {
log = os.Stderr
if !*verbose {
log = ioutil.Discard
}
if *mountPoint == "" {
*mountPoint = "/ebs/" + *volumeID
}
instanceID = oldaws.InstanceId()
if instanceID == "unknown" {
return fmt.Errorf("cannot determine AWS instance ID. not running in EC2?")
}
region := oldaws.InstanceRegion()
ec2Conn := ec2.New(&aws.Config{Region: region})
if *unmountOnly {
err1 := Unmount()
err2 := Detach(ec2Conn)
if err1 != nil {
return err1
}
return err2
}
var err error
linuxDeviceName := ""
awsDeviceName := ""
for i := 'a'; true; i++ {
awsDeviceName = fmt.Sprintf("/dev/sd%c", i)
linuxDeviceName = fmt.Sprintf("/dev/xvd%c", i)
_, err = os.Stat(linuxDeviceName)
if err != nil && os.IsNotExist(err) {
fmt.Fprintf(log, "found device %s\n", linuxDeviceName)
break
}
if err != nil {
fmt.Fprintf(log, "%s: %s\n", linuxDeviceName, err)
}
if i == 'z' {
return fmt.Errorf("Cannot locate an available device to mount")
}
}
fmt.Fprintf(log, "attaching %s to %s\n", *volumeID, awsDeviceName)
_, err = ec2Conn.AttachVolume(&ec2.AttachVolumeInput{
Device: &awsDeviceName,
InstanceID: &instanceID,
VolumeID: volumeID,
})
if err != nil {
return fmt.Errorf("failed to attach %s at %s: %s",
*volumeID, awsDeviceName, err)
}
defer func() {
fmt.Fprintf(log, "detaching %s from %s\n", *volumeID, awsDeviceName)
if !*mountOnly || err != nil {
if cleanupErr := Detach(ec2Conn); cleanupErr != nil {
fmt.Fprintf(os.Stderr, "failed to detach %s: %s\n", *volumeID, cleanupErr)
}
}
}()
// Wait for the volume to attach
for i := time.Duration(0); i < *attachTimeout; i += time.Second {
_, err = os.Stat(linuxDeviceName)
if err == nil {
break
}
if !os.IsNotExist(err) {
break
}
time.Sleep(time.Second)
}
if err != nil {
return fmt.Errorf("failed to attach %s: %s\n", linuxDeviceName, err)
}
// Use blkid to tell if we need to create a filesystem
_, err = exec.Command("blkid", linuxDeviceName).Output()
if err != nil && err.Error() == "exit status 2" {
// blkid told us we have no filesystem, so create one
fmt.Fprintf(log, "Creating filesystem on %s\n", *volumeID)
err = exec.Command(fmt.Sprintf("mkfs.%s", *fsType), linuxDeviceName).Run()
if err != nil {
return err
}
}
// Mount the file system
fmt.Fprintf(log, "mounting %s on %s\n", linuxDeviceName, *mountPoint)
os.MkdirAll(*mountPoint, 0777)
err = exec.Command("mount", linuxDeviceName, *mountPoint).Run()
if err != nil {
return fmt.Errorf("cannot mount %s: %s", *volumeID, err)
}
defer func() {
if !*mountOnly || err != nil {
fmt.Fprintf(log, "unmounting %s from %s\n", linuxDeviceName, *mountPoint)
if cleanupErr := Unmount(); cleanupErr != nil {
fmt.Fprintf(os.Stderr, "failed to unmount %s: %s\n", *volumeID, cleanupErr)
}
}
}()
if *mountOnly {
return nil
}
// Invoke the command
fmt.Fprintf(log, "invoking %s %#v\n", flag.Arg(0), flag.Args()[1:])
cmd := exec.Command(flag.Arg(0), flag.Args()[1:]...)
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
// Catch shutdown signals and make sure we cleanup
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, os.Interrupt, os.Kill)
// Run the command. When finished, close the signalCh to wake up the main
// "thread".
var cmdErr error
go func() {
cmdErr = cmd.Run()
close(signalCh)
}()
// Wait for the command to stop or a signal to arrive
_ = <-signalCh
return cmdErr
}
func main() {
var inst_id string
if instanceID == "" {
inst_id := aws.InstanceId()
if inst_id == "unknown" {
log.Fatalln("Unable to get instance id")
}
} else {
inst_id = instanceID
}
auth, err := aws.GetAuth(accesskey, secretkey, "", time.Time{})
if err != nil {
log.Fatalln("Unable to get AWS auth", err)
}
if securityGroupID != "" {
awsec2 = ec2.New(auth, aws.GetRegion(region))
groupMap := getSecurityGroupIds(inst_id)
groupMap[securityGroupID] = true
groupIds := make([]string, 0, len(groupMap))
for id := range groupMap {
groupIds = append(groupIds, id)
}
opts := &ec2.ModifyInstanceAttributeOptions{SecurityGroups: ec2.SecurityGroupIds(groupIds...)}
resp, err := awsec2.ModifyInstanceAttribute(inst_id, opts)
if err != nil || !resp.Return {
log.Fatalln("Error adding security group to instance", err)
}
log.Printf("Added security group %s to instance %s\n", securityGroupID, inst_id)
}
awselb := elb.New(auth, aws.GetRegion(region))
for _, lbname := range lbnames {
_, err = awselb.RegisterInstancesWithLoadBalancer([]string{inst_id}, lbname)
if err != nil {
log.Fatalln("Error registering instance", err)
}
log.Printf("Registered instance %s with elb %s\n", inst_id, lbname)
}
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
// this waits until we get a kill signal
<-c
for _, lbname := range lbnames {
_, err = awselb.DeregisterInstancesFromLoadBalancer([]string{inst_id}, lbname)
if err != nil {
log.Fatalln("Error deregistering instance", err)
}
log.Printf("Deregistered instance %s with elb %s\n", inst_id, lbname)
}
if securityGroupID != "" {
groupMap := getSecurityGroupIds(inst_id)
delete(groupMap, securityGroupID)
groupIds := make([]string, 0, len(groupMap))
for id := range groupMap {
groupIds = append(groupIds, id)
}
opts := &ec2.ModifyInstanceAttributeOptions{SecurityGroups: ec2.SecurityGroupIds(groupIds...)}
resp, err := awsec2.ModifyInstanceAttribute(inst_id, opts)
if err != nil || !resp.Return {
log.Fatalln("Error removing security group from instance", err)
}
log.Printf("Removed security group %s from instance %s\n", securityGroupID, inst_id)
}
}
func main() {
flag.Parse()
dockerClient, err := docker.NewClient(*dockerEndpoint)
if err != nil {
fmt.Printf("cannot connect to docker: %s\n", err)
os.Exit(1)
}
// Wait for the container to start
// TODO(ross): this could be done with the events interface perhaps?
for {
_, err := dockerClient.InspectContainer(*containerID)
if err == nil {
break
}
if _, ok := err.(*docker.NoSuchContainer); ok {
time.Sleep(time.Second)
continue
}
fmt.Printf("docker: %s: %s\n", *containerID, err)
os.Exit(1)
}
instanceID := aws.InstanceId()
if instanceID == "unknown" {
fmt.Printf("cannot determine AWS instance ID. not running in EC2?\n")
os.Exit(1)
}
awsAuth, err := aws.GetAuth("", "", "", time.Time{})
if err != nil {
fmt.Printf("cannot get AWS auth: %s\n", err)
os.Exit(1)
}
elbConn := elb.New(awsAuth, aws.GetRegion(aws.InstanceRegion()))
_, err = elbConn.RegisterInstancesWithLoadBalancer(
[]string{instanceID},
*loadBalancerName)
if err != nil {
fmt.Printf("cannot register instance: %s\n", err)
os.Exit(1)
}
fmt.Printf("registered instance %s from ELB %s\n", instanceID,
*loadBalancerName)
// Wait for the container to exit
_, err = dockerClient.WaitContainer(*containerID)
if err != nil {
fmt.Printf("docker: %s: waiting: %s\n", *containerID, err)
} else {
fmt.Printf("docker: %s exited\n", *containerID)
}
_, err = elbConn.DeregisterInstancesFromLoadBalancer(
[]string{instanceID}, *loadBalancerName)
if err != nil {
fmt.Printf("cannot unregister instance: %s\n", err)
os.Exit(1)
}
fmt.Printf("unregisterd instance %s from ELB %s\n",
instanceID, *loadBalancerName)
}