Exemple #1
0
func init() {
	cluster = gocql.NewCluster("127.0.0.1")
	// uncomment the following two lines if you want to use Cassandra 1.2
	// cluster.ProtoVersion = 1
	// cluster.CQLVersion = "3.0.0"
	session, _ = cluster.CreateSession()
}
Exemple #2
0
func fetchCards() (card CardPerso) {

	card = CardPerso{}
	cardInfo := Persod{}

	// connect to the cluster
	cluster := gocql.NewCluster(cassandraAddress)
	cluster.Keyspace = keyspaceName
	cluster.Consistency = gocql.One
	cluster.ProtoVersion = 1

	session, err := cluster.CreateSession()
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	iter := session.Query(walletDataQuery).Iter()
	for iter.Scan(&cardInfo.WalletId, &cardInfo.DeviceProfileId, &cardInfo.SeProfileId, &cardInfo.AppletInstanceProfiles, &cardInfo.DeviceProfile, &cardInfo.IssuerId, &cardInfo.PackageProfiles, &cardInfo.RegistrationStatus, &cardInfo.RestrictedAids, &cardInfo.SdProfileId, &cardInfo.SecurityDomainServiceendPtnId, &cardInfo.SeProfile) {
		cardInfo.AppletJson = copyMapToJson(cardInfo.AppletInstanceProfiles)
		log.Printf("AppletInstanceProfiles = %s", cardInfo.AppletJson)
		cardInfo.PackageJson = copyMapToJson(cardInfo.PackageProfiles)
		log.Printf("%s", cardInfo.PackageJson)

		card.Perso = append(card.Perso, cardInfo)
	}
	if err := iter.Close(); err != nil {
		log.Fatal("scan problem:", err)
	}

	return card
}
Exemple #3
0
// NewQueueManager constructs a new QueueManager with a given name and
// configuration. The QueueManagerConfig is copied by value, so attempts to
// mutate a configuration already passed to NewQueueManager will have no
// effect.
func NewQueueManager(name string, config QueueManagerConfig) (*QueueManager, error) {
	cassCluster := gocql.NewCluster(config.CassandraHosts...)
	cassCluster.Keyspace = config.CassandraKeyspace
	cassSession, err := cassCluster.CreateSession()

	if err != nil {
		return nil, err
	}

	mgr := &QueueManager{
		Name:          name,
		config:        config,
		writers:       make(map[string]*queueWriter),
		db:            cassSession,
		done:          &sync.WaitGroup{},
		stopKeepAlive: make(chan bool),
	}

	go mgr.keepAlive()
	return mgr, nil
}
Exemple #4
0
func main() {
	// Command line Args
	var ip = flag.String("c", "127.0.0.1", "IP address of Cluster")
	var ks = flag.String("k", "stress_keyspace", "Keyspace for stress (will be created if it does not exist)")
	var table = flag.String("t", "stress_table", "Table for stress (will be created if it does not exist)")
	var num_ops = flag.Int("n", 1000000, "Number of operations to preform")
	var parallel = flag.Int("p", 40, "Number of Parallel Operations")
	flag.Parse()
	fmt.Println("IP:", *ip)

	// connect to the cluster
	cluster := gocql.NewCluster(*ip)
	session, err := cluster.CreateSession()
	if err != nil {
		panic(fmt.Sprintf("Could not create Session: %v", err))
	}
	defer session.Close()

	createks(session, *ks, *table)

	fmt.Println("Queing up Operations")
	go stress(*num_ops)
	for p := 0; p < *parallel; p++ {
		go insert(session)
	}
	// start selectors put a for loop here
	//go select(session, ops_select, done)
	c_done := 0
	for x := range done {
		fmt.Println(x)
		c_done++
		fmt.Println(c_done)
		if c_done == *parallel {
			close(done)
		}
	}

}
Exemple #5
0
//This test checks to make sure a valid error and a nil reference to
//a session are returned when an empty array of hosts are provided
//to the cluster configuration
func TestEmptyHosts() error {
	empty := make([]string, 0)
	cfg := gocql.NewCluster(empty...)
	_, err := cfg.CreateSession()
	return err
}
func Init() {
	cluster := c.NewCluster("127.0.0.1")
	cluster.Keyspace = "mykeyspace"
	cluster.Consistency = c.One
	Cl = cluster
}
Exemple #7
0
func main() {

	var in *os.File
	var err error

	var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
	var event_file = flag.String("event_file", "", "event file")

	flag.Parse()
	if *event_file == "" {
		panic("must pass an event file")
	}

	if *cpuprofile != "" {
		f, err := os.Create(*cpuprofile)
		if err != nil {
			panic(err)
		}
		pprof.StartCPUProfile(f)
		defer pprof.StopCPUProfile()
	}

	init_globals()

	fmt.Printf("Opening event file %s....\n", *event_file)
	if in, err = os.Open(*event_file); err != nil {
		panic(err)
	}

	// connect to the cluster
	cluster := gocql.NewCluster("10.168.16.195", "10.168.16.196")
	cluster.Keyspace = "logs_ks"
	cluster.Consistency = gocql.Quorum
	session, _ := cluster.CreateSession()
	defer session.Close()

	scanner := bufio.NewScanner(in)
	line := ""
	var parts []string

	line_num := 0
	var batch *gocql.Batch
	rowdata := make([]interface{}, len(columns))

	for scanner.Scan() {
		line = scanner.Text()
		line_num++
		parts = strings.SplitN(line, "\t", 7)
		if len(parts) != 7 {
			log.Printf("Bad line %d in event file: %s\n", line_num, *event_file)
			continue
		}

		if batch == nil {
			batch = gocql.NewBatch(gocql.LoggedBatch)
		}

		col_idx := 0
		var val_fl float64
		var val_bl bool
		var val_int int
		var ts time.Time

		for _, k := range columns {
			switch logfile_spec[k].data_type {
			case "integer":
				val_int, err = strconv.Atoi(parts[logfile_spec[k].indx])
				if err == nil {
					val_int = 0
				}
				rowdata[col_idx] = val_int
			case "float":
				val_fl, err = strconv.ParseFloat(parts[logfile_spec[k].indx], 32)
				if err == nil {
					val_fl = 0.0
				}
				rowdata[col_idx] = float32(val_fl)
			case "boolean":
				val_bl, err = strconv.ParseBool(parts[logfile_spec[k].indx])
				if err == nil {
					val_bl = false
				}
				rowdata[col_idx] = val_bl
			case "timestamp":
				// Reference MAGIC time: Mon Jan 2 15:04:05 -0700 MST 2006
				ts, err = time.Parse("20060102150405", parts[logfile_spec[k].indx])
				if err != nil {
					log.Printf("Bad time in line %d in event file: %s\n", line_num, *event_file)
					continue // can't make fake timestamp
				}
				rowdata[col_idx] = ts
			default: // strings varchar / ascii etc
				rowdata[col_idx] = parts[logfile_spec[k].indx]
			}
			col_idx += 1
		}
		//log.Printf("parts = %v", parts)
		//log.Printf("rowdata = %v", rowdata)

		batch.Query(insert_query1, rowdata...)

		batch_count := len(batch.Entries)
		if batch_count >= 2000 {
			if err := session.ExecuteBatch(batch); err != nil {
				log.Printf("Failed to execute batch: %v", err)
			}
			batch = nil
			log.Printf("Done with batch of %d", batch_count)
		}
	}
	if batch != nil && len(batch.Entries) > 0 {
		batch_count := len(batch.Entries)
		if err := session.ExecuteBatch(batch); err != nil {
			log.Printf("Failed to execute batch: %v", err)
		}
		batch = nil
		log.Printf("Done with batch of %d", batch_count)
	}
	in.Close()

}